From: Dmitry Yu Okunev Date: Wed, 4 Jan 2017 21:42:01 +0900 Subject: dependency loop resolver Update 2018-02-17: tdestroy in glibc has been updated, giving segment fault. Remove bundled implementation and force _GNU_SOURCE. Description: remove the weak dependency loop in rc-update -u, while exit on strong loop. Forwarded: https://bugs.gentoo.org/show_bug.cgi?id=391945 Contributor: Steven Chamberlain , Benda Xu Origin: https://github.com/xaionaro/openrc --- etc/rc.conf | 6 + src/includes/helpers.h | 12 + src/librc/Makefile | 5 +- src/librc/librc-depend.c | 868 ++++++++++++++++++++++++++++++++++++- src/librc/rc.h.in | 15 +- src/rc/rc-misc.c | 8 +- src/test/units/early_loop_detector | 196 +++++++++ 7 files changed, 1102 insertions(+), 8 deletions(-) create mode 100644 src/test/units/early_loop_detector --- a/etc/rc.conf +++ b/etc/rc.conf @@ -154,6 +154,12 @@ # This is mainly used for saying which services do NOT provide net. #rc_net_tap0_provide="!net" +# Comment this line to disable dependency loop solver +rc_loopsolver_enable="YES" + +# Comment this line to disable warnings about dependency loops +rc_loopsolver_warnings="YES" + # This is the subsystem type. # It is used to match against keywords set by the keyword call in the # depend function of service scripts. --- a/src/shared/helpers.h +++ b/src/shared/helpers.h @@ -19,6 +19,7 @@ #define __HELPERS_H__ #define ERRX fprintf (stderr, "out of memory\n"); exit (1) +#define bitsizeof(a) (CHAR_BIT*sizeof(a)) #define UNCONST(a) ((void *)(unsigned long)(const void *)(a)) @@ -65,6 +66,17 @@ if (value) return (value); + + ERRX; + /* NOTREACHED */ +} + +_unused static void *xcalloc(size_t nmemb, size_t size) +{ + void *value = calloc(nmemb, size); + + if (value) + return (value); ERRX; /* NOTREACHED */ --- a/src/librc/librc-depend.c +++ b/src/librc/librc-depend.c @@ -15,15 +15,46 @@ * except according to the terms contained in the LICENSE file. */ +#define _GNU_SOURCE #include +#include /* hsearch() */ +#include /* uint32_t/uint64_t */ #include "queue.h" #include "librc.h" +#include "einfo.h" #define GENDEP RC_LIBEXECDIR "/sh/gendepends.sh" #define RC_DEPCONFIG RC_SVCDIR "/depconfig" +#define LOOPSOLVER_LIMIT 128 +/*! Type definition of service ID */ +typedef uint32_t service_id_t; + +/*! Enumeration of solve_loop()'s return cases */ +typedef enum loopfound { + LOOP_SOLVABLE = 0x01, + LOOP_UNSOLVABLE = 0x02, + LOOP_CANCELED = 0x03, +} loopfound_t; + +/* "use, need, after" dependencies matrix types */ +typedef enum unapm_type { + UNAPM_USE = 0, + UNAPM_AFTER = 1, + UNAPM_NEED = 2, + UNAPM_PROVIDEDBY = 3, + UNAPM_MIXED = 4, + UNAPM_MIXED_EXPANDED = 5, + UNAPM_MAX +} unapm_type_t; + +typedef struct idid_entry { + uint64_t idid; + void *data; +} idid_entry_t; + static const char *bootlevel = NULL; static char * @@ -732,7 +763,731 @@ return newer; } -/* This is a 7 phase operation +static inline int +unapm_expandsdeps(service_id_t **unap, service_id_t service_id) +{ + int dep_num, dep_count; + int ismodified; + + ismodified = 0; + dep_num = 0; + dep_count = unap[service_id][0]; + while (dep_num < dep_count) { + service_id_t dep_service_id; + int dep_dep_num, dep_dep_count; + + dep_num++; + dep_service_id = unap[service_id][dep_num]; + /*printf("service_id == %i; dep_num == %i (%i); dep_service_id == %i\n", service_id, dep_num, dep_count, dep_service_id);*/ + + dep_dep_num = 0; + dep_dep_count = unap[dep_service_id][0]; + + while (dep_dep_num < dep_dep_count) { + int istoadd, dep_num_2; + service_id_t dep_dep_service_id; + dep_dep_num++; + + dep_dep_service_id = unap[dep_service_id][dep_dep_num]; + + istoadd = 1; + dep_num_2 = 0; + while (dep_num_2 < dep_count) { + dep_num_2++; + if (dep_dep_service_id == unap[service_id][dep_num_2]) { + istoadd = 0; + break; + } + } + + if (istoadd) { + ismodified = 1; + dep_count++; + unap[service_id][dep_count] = dep_dep_service_id; + unap[service_id][0] = dep_count; + } + } + } + + return ismodified; +} + +/*! Fills dependency matrix for further loop detection + * @param unap_matrix matrix to fill + * @param useneedafter_count number of use/need/after/provide dependencies (zero to do not allocate memory) + * @param service_id ID of the service for dependency scanning + * @param type dependencies type + * @param depinfo dependencies information */ +static void +unapm_getdependencies(service_id_t **unap_matrix, + int useneedafter_count, service_id_t service_id, + const char *type, RC_DEPINFO *depinfo) +{ + RC_STRING *svc, *svc_np; + RC_DEPTYPE *deptype; + + if (useneedafter_count) + unap_matrix[service_id] = xcalloc((useneedafter_count+1), sizeof(**unap_matrix)); + + deptype = get_deptype(depinfo, type); + if (deptype == NULL) + return; + + TAILQ_FOREACH_SAFE(svc, deptype->services, entries, svc_np) { + ENTRY item, *item_p; + service_id_t dependon; + + item.key = svc->value; + + item_p = hsearch(item, FIND); + if (item_p == NULL) /* Deadend branch, no sense to continue checking it anyway */ + continue; + + dependon = (int)(long int)item_p->data; + + if (dependon == service_id) + continue; /* To prevent looping detection services on themselves (for example in case of depending on '*') */ + + unap_matrix[service_id][ ++unap_matrix[service_id][0] ] = dependon; + } + + return; +} + +static int +svc_id2depinfo_bt_compare(const void *a, const void *b) +{ + return ((const ENTRY *)a)->key - ((const ENTRY *)b)->key; +} + +static int +idid_compare(const void *a, const void *b) +{ + return ((const idid_entry_t *)a)->idid - ((const idid_entry_t *)b)->idid; +} + +static int +idid_compare_data_desc(const void *a, const void *b) +{ + intptr_t a_dat = (intptr_t)(((const idid_entry_t *)a)->data); + intptr_t b_dat = (intptr_t)(((const idid_entry_t *)b)->data); + + return b_dat - a_dat; +} + +static inline char +deptype2char(unapm_type_t type) { + switch (type) { + case UNAPM_USE: + return 'u'; + case UNAPM_AFTER: + return 'a'; + case UNAPM_NEED: + return 'n'; + case UNAPM_PROVIDEDBY: + return 'p'; + default: /* shouldn't happend */ + return '?'; + } + + return '?'; +} + + +/*! an "action" function for twalk() to build an unsorted array of dependencies presence from prepared btree */ + +static int idid_btree_builddescarray_amount; /* number of elements of the result array (should be set to zero before running this function) */ +static idid_entry_t *idid_btree_builddescarray_counters; /* the result array (should be allocated before running this function) */ + +static void +idid_btree_builddescarray(const void *nodep, const VISIT which, const int depth) { + idid_entry_t *idid_counters = idid_btree_builddescarray_counters; /* Just a shorthand */ + (void)depth; + switch (which) { + case preorder: + case leaf: { + const idid_entry_t *idid_entry_p = *(idid_entry_t * const*)nodep; + + memcpy( + &idid_counters[idid_btree_builddescarray_amount], + idid_entry_p, + sizeof(idid_counters[idid_btree_builddescarray_amount]) + ); + idid_btree_builddescarray_amount++; + break; + } + default: + break; + } + return; +} + + +/*! removes a looping dependency (in both directions) + * @param unap matrixes to scan ways to solve the loop (it should be modified to be able to continue scanning after the dependency removing) + * @param dep_remove_from_service_id source service id of the dependency + * @param dep_remove_to_service_id destination service id of the dependency + * @param di_from RC_DEPINFO of the direct-way dependency + * @param di_to RC_DEPINFO of the reverse-way dependency + * @param type the direct-way dependency type (string, e.g. "iuse") + * @param unapm_type binary direct-way dependency type for the UNA matrix */ +static void +remove_loopdependency(service_id_t **unap[UNAPM_MAX], service_id_t dep_remove_from_service_id, service_id_t dep_remove_to_service_id, RC_DEPINFO *di_from, RC_DEPINFO *di_to, const char *const type, unapm_type_t unapm_type) +{ + RC_DEPTYPE *deptype_from = NULL, *deptype_to = NULL; + int dep_num, dep_count; + const char *type_reverse = NULL; + int deptype_num; + + /* removing use/after from cache */ + if (di_from != NULL) { + deptype_from = get_deptype(di_from, type); + if (deptype_from != NULL) + rc_stringlist_delete(deptype_from->services, di_to->service); + } + + /* removing from the UNAP matrix */ + if (deptype_from != NULL || di_from == NULL) { + dep_num = 0; + dep_count = unap[unapm_type][dep_remove_from_service_id][0]; + while (dep_num++ < dep_count) { + if (unap[unapm_type][dep_remove_from_service_id][dep_num] == dep_remove_to_service_id) { + unap[unapm_type][dep_remove_from_service_id][dep_num] = + unap[unapm_type][dep_remove_from_service_id][dep_count--]; + if (deptype_from != NULL && di_to != NULL) + ewarn("Solving the loop by breaking %s %c> %s.", + di_to->service, deptype2char(unapm_type), di_from->service); + } + } + unap[unapm_type][dep_remove_from_service_id][0] = dep_count; + } + + + /* removing the reverse dependency */ + + if (di_to == NULL) + return; + + deptype_num = 0; + while (deppairs[deptype_num].depend) { + if (!strcmp(deppairs[deptype_num].depend, type)) { + type_reverse = deppairs[deptype_num].addto; + break; + } + deptype_num++; + } + + deptype_to = get_deptype(di_to, type_reverse); + + if (deptype_to != NULL) + rc_stringlist_delete(deptype_to->services, di_from->service); + + return; +} + +/*! solves dependecies loops + * @param unap_matrix matrixes to scan ways to solve the loop + * @param service_id looped service id + * @param svc_id2depinfo_bt ptr to binary tree root to get depinfo by svc id + * @param end_dep_num looping dependency id in use/need/after/provide matrix line */ +static loopfound_t +solve_loop(service_id_t **unap_matrix[UNAPM_MAX], service_id_t service_id, void *svc_id2depinfo_bt, int end_dep_num, RC_DT_FLAGS flags) { + char **chain_strs = NULL; + service_id_t **chains; + unapm_type_t **deptypes; + unapm_type_t minimal_cost; + int chains_size = unap_matrix[0][0][0], chain_count; + + /* svc_id2depinfo_bt may be NULL while any unit tests to simplify them */ + char printwarn = (svc_id2depinfo_bt != NULL) && (flags & RCDTFLAGS_LOOPSOLVER_WARNINGS); + char printerr = svc_id2depinfo_bt != NULL; + + if (! (flags & RCDTFLAGS_LOOPSOLVER)) + return LOOP_CANCELED; + + chains = xmalloc(chains_size * sizeof(*chains)); + + /* building all dependency chains of the service */ + + { + + int dep_num, unap_line_size; + service_id_t *unap_line; + + unap_line_size = unap_matrix[UNAPM_MIXED_EXPANDED][service_id][0]+1; + unap_line = xmalloc(unap_line_size * sizeof(*unap_line)); + + memcpy(unap_line, unap_matrix[UNAPM_MIXED_EXPANDED][service_id], unap_line_size * sizeof(*unap_line)); + + unap_line[0] = service_id; + chain_count = 0; + dep_num = -1; + while (++dep_num < end_dep_num) { + int dep_dep_num, added_count; + service_id_t dep_service_id; + + dep_service_id = unap_line[dep_num]; + dep_dep_num = dep_num; + added_count = 0; + while (++dep_dep_num <= end_dep_num) { + int chain_num, chain_count_new, dep_dep_check_num, dep_dep_check_count, istobeadded; + service_id_t dep_dep_service_id, dep_dep_service_id_added; + + dep_dep_service_id = unap_line[dep_dep_num]; + + dep_dep_check_num = 0; + dep_dep_check_count = unap_matrix[UNAPM_MIXED][dep_service_id][0]; + istobeadded = 0; + while (dep_dep_check_num++ < dep_dep_check_count) { + if (unap_matrix[UNAPM_MIXED][dep_service_id][dep_dep_check_num] == dep_dep_service_id) { + istobeadded = 1; + break; + } + } + + if (istobeadded) { + int chain_len; + + chain_num = 0; + chain_count_new = chain_count; + +#define CHAINS_CHECK_SIZE {\ + if (chain_count_new >= chains_size) {\ + chains_size += unap_matrix[0][0][0];\ + chains = xrealloc(chains, chains_size*sizeof(*chains));\ + }\ + /*printf("A: %i\n", chain_count_new);*/\ + chains[chain_count_new] = xmalloc(end_dep_num*sizeof(**chains));\ + chains[chain_count_new][0] = 0;\ + } + + if (dep_num == 0) { + CHAINS_CHECK_SIZE; + chains[chain_count_new][1] = dep_dep_service_id; + chains[chain_count_new][0] = 1; + chain_count_new++; + } else + while (chain_num < chain_count) { + if (!added_count) { + chain_len = chains[chain_num][0]; + if (chains[chain_num][chain_len] == dep_service_id) { + chains[chain_num][++chain_len] = dep_dep_service_id; + dep_dep_service_id_added = dep_dep_service_id; + chains[chain_num][0] = chain_len; + } + } else { + /* required chains were been enlarged by previous iteration, so "-1" */ + chain_len = chains[chain_num][0]-1; + if (chains[chain_num][chain_len] == dep_service_id && chains[chain_num][chain_len+1] == dep_dep_service_id_added) { + CHAINS_CHECK_SIZE; + memcpy(chains[chain_count_new], chains[chain_num], (chain_len+1)*sizeof(**chains)); + chains[chain_count_new][++chain_len] = dep_dep_service_id; + chains[chain_count_new][0] = chain_len; + chain_count_new++; + } + } + chain_num++; + } + added_count++; + chain_count = chain_count_new; + } + } + } + + free(unap_line); + } + + /* removing non-looping chains */ + + { + int i; + + i = 0; + while (i < chain_count) { + int j, chain_len, islooping; + + chain_len = chains[i][0]; + + islooping = 0; + j = 0; + while (j++ < chain_len) + if (chains[i][j] == service_id) { + islooping = 1; + break; + } + + if (!islooping) { + free(chains[i]); + chains[i] = chains[--chain_count]; + continue; + } + + i++; + } + } + + /* getting dependencies types */ + + { + int i; + deptypes = xmalloc(chain_count * sizeof(*deptypes)); + + i = 0; + while (i < chain_count) { + int j, chain_len; + + chain_len = chains[i][0]; + + deptypes[i] = xmalloc((chain_len+1) * sizeof(**deptypes)); + + j = 0; + while (j++ < chain_len) { + service_id_t dep_service_id_from, dep_service_id_to; + unapm_type_t type; + + dep_service_id_from = j==1 ? service_id : chains[i][j-1]; + dep_service_id_to = chains[i][j]; + + type = UNAPM_PROVIDEDBY+1; + while (type-- > 0) { + int dep_dep_num, dep_dep_count; + dep_dep_num = 0; + dep_dep_count = unap_matrix[type][dep_service_id_from][0]; + + while (dep_dep_num++ < dep_dep_count) { + if (unap_matrix[type][dep_service_id_from][dep_dep_num] == dep_service_id_to) { + deptypes[i][j] = type; + type = 0; /* to break parent while (), too */ + break; + } + } + } + } + i++; + } + } + + /* preparing services chain for further printing */ + + if (printwarn || printerr) { + int chain_num; + chain_strs = xmalloc(chain_count * sizeof(*chain_strs)); + + chain_num = 0; + while (chain_num < chain_count) { + char *chain_str, *chain_str_end; + int chain_len; + + chain_str = chain_strs[chain_num] = xmalloc(BUFSIZ); + chain_str_end = &chain_str[BUFSIZ-2]; + + /* Preparing a string of services forming the loop */ + { + char *ptr_dst; + int i; + + ptr_dst = chain_str; + + chain_len = chains[chain_num][0]; + chains[chain_num][0] = service_id; + + i = chain_len+1; + while (i--) { + ENTRY item, **item_pp; + RC_DEPINFO *depinfo; + const char *service_name, *ptr_src; + + item.key = (void *)(long)chains[chain_num][i]; + item_pp = tfind(&item, &svc_id2depinfo_bt, svc_id2depinfo_bt_compare); + depinfo = (RC_DEPINFO *)((ENTRY *)*item_pp)->data; + + service_name = depinfo->service; + + ptr_src = service_name; + while (*ptr_src && (ptr_dst < chain_str_end)) + *(ptr_dst++) = *(ptr_src++); + + if (ptr_dst >= chain_str_end) { + ptr_dst--; + break; + } + + if (i) { + if (&ptr_dst[4] >= chain_str_end) + break; + + *(ptr_dst++) = ' '; + *(ptr_dst++) = deptype2char(deptypes[chain_num][i]); + memcpy(ptr_dst, "> ", 2); + ptr_dst += 2; + } + } + + chains[chain_num][0] = chain_len; + + *ptr_dst = 0; + } + +/* + { + int j; + chain_len = chains[chain_num][0]; + j = 0; + printf("%i: %i (%i):", service_id, chain_num, chain_len); + while (j++ < chain_len) + printf(" %i<%i>", chains[chain_num][j], deptypes[chain_num][j]); + printf("\n"); + } +*/ + chain_num++; + } + + } + + /* checking the cost of loop solving (use/after/need) */ + + { + int i; + + minimal_cost = 0; + i = 0; + while (i < chain_count) { + int j, chain_len; + unapm_type_t chain_cost; + + chain_cost = UNAPM_MAX; + + chain_len = chains[i][0]; + j = 0; + while (j++ < chain_len) + chain_cost = MIN(chain_cost, deptypes[i][j]); + + minimal_cost = MAX(minimal_cost, chain_cost); + +/* + RC_DEPINFO *depinfo; + ENTRY item, **item_pp; + item.key = (void *)(long)service_id; + item_pp = tfind(&item, &svc_id2depinfo_bt, svc_id2depinfo_bt_compare); + depinfo = (RC_DEPINFO *)((ENTRY *)*item_pp)->data; +*/ + if (minimal_cost > UNAPM_AFTER) { + if (printerr) + eerror("Found an unresolvable dependency: %s.", chain_strs[i]); + } else { + if (printwarn) + ewarn("Found a solvable dependency loop: %s.", chain_strs[i]); + } + + i++; + } + /*printf("minimal cost: %i\n", minimal_cost);*/ + + if (minimal_cost > UNAPM_AFTER) + return LOOP_UNSOLVABLE; + } + + /* calculating optimal way to solve the loop and solving it */ + + { + void *btree = NULL; + uint64_t *idid_to_break; + int idid_count, idid_to_break_count; + idid_to_break = xmalloc(chain_count * sizeof(*idid_to_break)); + + /* counting a presence of each dependency through all chains */ + { + int i; + + idid_count = 0; + i = 0; + while (i < chain_count) { + int j, chain_len; + + chain_len = chains[i][0]; + j = 0; + while (j++ < chain_len) { + uint64_t idid; + service_id_t service_id_from, service_id_to; + idid_entry_t idid_entry, *idid_entry_p; + void *tfind_res; + + if (deptypes[i][j] > minimal_cost) /* we don't break this dependency, skipping */ + continue; + + service_id_from = j>1 ? chains[i][j-1] : service_id; + service_id_to = chains[i][j]; + + idid = ((uint64_t)service_id_from << bitsizeof(service_id_to)) | service_id_to; + + idid_entry.idid = idid; + tfind_res = tfind(&idid_entry, &btree, idid_compare); + /*printf("A: (%i -> %i) %li: %p: %p\n", service_id_from, service_id_to, idid, tfind_res, tfind_res==NULL?NULL:*(idid_entry_t **)tfind_res);*/ + if (tfind_res == NULL) { + idid_entry_p = xmalloc(sizeof(*idid_entry_p)); + idid_entry_p->idid = idid; + idid_entry_p->data = (void *)1; + tsearch(idid_entry_p, &btree, idid_compare); + idid_count++; + } else { + idid_entry_p = *(idid_entry_t **)tfind_res; + idid_entry_p->data = (void *)((long)idid_entry_p->data + 1); + } + } + + i++; + } + } + + /* building array of dependencies sorted by descending presence counter */ + + { + int idid_count2; + + idid_btree_builddescarray_counters = xmalloc(idid_count * sizeof(*idid_btree_builddescarray_counters)); + idid_btree_builddescarray_amount = 0; + + twalk(btree, idid_btree_builddescarray); + + qsort( + idid_btree_builddescarray_counters, + idid_btree_builddescarray_amount, + sizeof(*idid_btree_builddescarray_counters), + idid_compare_data_desc + ); + + idid_to_break_count = MIN(idid_btree_builddescarray_amount, chain_count); + idid_count2 = 0; + while (idid_count2 < idid_to_break_count) { + idid_to_break[idid_count2] = idid_btree_builddescarray_counters[idid_count2].idid; + /*printf("B: %li %li\n", idid_counters[idid_count2].idid, (long)idid_counters[idid_count2].data);*/ + idid_count2++; + } + + free(idid_btree_builddescarray_counters); + } + + /* solving loops */ + + { + idid_count = 0; + while (idid_count < idid_to_break_count) { + service_id_t service_id_from, service_id_to; + + service_id_from = ((uint64_t)idid_to_break[idid_count] & ((uint64_t)((service_id_t)~0) << bitsizeof(service_id_t))) >> bitsizeof(service_id_t); + service_id_to = idid_to_break[idid_count] & ((service_id_t)~0); + + idid_count++; + + { + ENTRY item, **item_pp; + RC_DEPINFO *depinfo_from = NULL, *depinfo_to = NULL; + + if (printwarn) { + item.key = (void *)(long)service_id_from; + item_pp = tfind(&item, &svc_id2depinfo_bt, svc_id2depinfo_bt_compare); + depinfo_from = (RC_DEPINFO *)((ENTRY *)*item_pp)->data; + + item.key = (void *)(long)service_id_to; + item_pp = tfind(&item, &svc_id2depinfo_bt, svc_id2depinfo_bt_compare); + depinfo_to = (RC_DEPINFO *)((ENTRY *)*item_pp)->data; + } + + /* Remove weak dependency */ + + remove_loopdependency(unap_matrix, service_id_from, service_id_to, depinfo_from, depinfo_to, "iuse", UNAPM_USE); + remove_loopdependency(unap_matrix, service_id_from, service_id_to, depinfo_from, depinfo_to, "iafter", UNAPM_AFTER); + + } + } + } + + /* cleanup */ + + tdestroy(btree, free); + free(idid_to_break); + } + + /* cleanup */ + { + int i; + + i = 0; + while (i < chain_count) { + if (printwarn || printerr) + free(chain_strs[i]); + free(deptypes[i]); + free(chains[i]); + i++; + } + if (printwarn || printerr) + free(chain_strs); + free(deptypes); + free(chains); + } + + return LOOP_SOLVABLE; +} + +/*! Mixing all dependencies to UNAPM_MIXED and expanding them (with dependencies of dependencies) in UNAPM_MIXED_EXPANDED + * @param unap_matrix matrixes to scan ways to solve the loop + * @param useneedafter_count total count of use/need/before/provide relations */ +static void +unapm_prepare_mixed(service_id_t **unap_matrix[UNAPM_MAX], unsigned int useneedafter_count) { + service_id_t service_id; + int onemorecycle; + + /* getting pre-matrix of all dependencies types together */ + + service_id = 1; + while (service_id < (useneedafter_count+1)) { + service_id_t services_dst; + unapm_type_t unapm_type; + + memset(unap_matrix[UNAPM_MIXED][service_id], 0, (useneedafter_count+1) * sizeof(**unap_matrix)); + services_dst = 0; + unapm_type = 0; + while (unapm_type < UNAPM_MIXED) { + service_id_t services_src; + + services_src = unap_matrix[unapm_type][service_id][0]; + while (services_src) { + unap_matrix[UNAPM_MIXED][service_id][ ++services_dst ] = + unap_matrix[unapm_type][service_id][ services_src-- ]; + } + unapm_type++; + } + unap_matrix[UNAPM_MIXED][service_id][0] = services_dst; + service_id++; + } + + /* preparing full dependencies matrix */ + + /* copying UNAPM_MIXED -> UNAPM_MIXED_EXPANDED */ + service_id = 1; + while (service_id < (useneedafter_count+1)) { + memcpy(unap_matrix[UNAPM_MIXED_EXPANDED][service_id], unap_matrix[UNAPM_MIXED][service_id], (useneedafter_count+1) * sizeof(**unap_matrix)); + service_id++; + } + + do { + onemorecycle = 0; + + /* direct way: service_id = 1 -> end */ + service_id = 1; + while (service_id < (useneedafter_count+1)) + onemorecycle += unapm_expandsdeps(unap_matrix[UNAPM_MIXED_EXPANDED], service_id++); + + /* reverse way: service_id = end -> 1 */ + while (--service_id) + onemorecycle += unapm_expandsdeps(unap_matrix[UNAPM_MIXED_EXPANDED], service_id); + + } while (onemorecycle); + + return; +} + +/* This is an 8 phase operation Phase 1 is a shell script which loads each init script and config in turn and echos their dependency info to stdout Phase 2 takes that and populates a depinfo object with that data @@ -741,10 +1496,11 @@ Phase 5 removes broken before dependencies Phase 6 looks for duplicate services indicating a real and virtual service with the same names - Phase 7 saves the depinfo object to disk + Phase 7 check for loops + Phase 8 saves the depinfo object to disk */ bool -rc_deptree_update(void) +rc_deptree_update(RC_DT_FLAGS flags) { FILE *fp; RC_DEPTREE *deptree, *providers; @@ -759,6 +1515,7 @@ bool retval = true; const char *sys = rc_sys(); struct utsname uts; + unsigned int useneedafter_count=0; int serrno; /* Some init scripts need RC_LIBEXECDIR to source stuff @@ -963,6 +1720,8 @@ rc_stringlist_add(types, "iuse"); rc_stringlist_add(types, "iafter"); TAILQ_FOREACH(depinfo, deptree, entries) { + useneedafter_count++; + deptype = get_deptype(depinfo, "ibefore"); if (!deptype) continue; @@ -1021,7 +1780,108 @@ } rc_stringlist_free(dupes); - /* Phase 7 - save to disk + /* Phase 7 - check for loops (non-recursive way) */ + if (flags & RCDTFLAGS_LOOPSOLVER) + { + int loopfound; + unapm_type_t unapm_type; + service_id_t **unap_matrix[UNAPM_MAX]; + service_id_t service_id; + void *svc_id2depinfo_bt = NULL; + int loopsolver_counter = 0; + + hcreate(useneedafter_count*2); + + unapm_type = 0; + while (unapm_type < UNAPM_MAX) + unap_matrix[unapm_type++] = xmalloc(sizeof(*unap_matrix) * (useneedafter_count+1)); + + /* preparing a hash-table: service_name -> service_id */ + service_id = 1; + TAILQ_FOREACH(depinfo, deptree, entries) { + ENTRY item, *item_p; + + item.key = depinfo->service; + item.data = (void *)(long int)service_id; + hsearch(item, ENTER); + + item_p = xmalloc(sizeof(*item_p)); + item_p->key = (void *)(long int)service_id; + item_p->data = depinfo; + tsearch(item_p, &svc_id2depinfo_bt, svc_id2depinfo_bt_compare); + + service_id++; + } + + unap_matrix[0][0] = xmalloc(sizeof(***unap_matrix)*1); + unap_matrix[0][0][0] = service_id; + + /* getting dependencies pre-matrixes */ + service_id = 1; + TAILQ_FOREACH(depinfo, deptree, entries) { + unapm_getdependencies(unap_matrix[UNAPM_USE], useneedafter_count, service_id, "iuse", depinfo); + unapm_getdependencies(unap_matrix[UNAPM_NEED], useneedafter_count, service_id, "ineed", depinfo); + unapm_getdependencies(unap_matrix[UNAPM_PROVIDEDBY], useneedafter_count, service_id, "providedby", depinfo); + unapm_getdependencies(unap_matrix[UNAPM_AFTER], useneedafter_count, service_id, "iafter", depinfo); + service_id++; + } + + hdestroy(); + + /* getting pre-matrix of all dependencies types together (allocating memory) */ + + service_id = 1; + while (service_id < (useneedafter_count+1)) { + unap_matrix[UNAPM_MIXED ][service_id] = xmalloc((useneedafter_count+1) * sizeof(**unap_matrix)); + unap_matrix[UNAPM_MIXED_EXPANDED][service_id] = xmalloc((useneedafter_count+1) * sizeof(**unap_matrix)); + service_id++; + } + + do { + loopfound = 0; + + /* updating UNAPM_MIXED and UNAPM_MIXED_EXPANDED in UNAP matrix */ + + unapm_prepare_mixed(unap_matrix, useneedafter_count); + + /* detecting and solving loop (non-recursive method) */ + /* the loop is a situation where service is depended on itself */ + service_id=1; + while ((service_id < (useneedafter_count+1)) && !loopfound) { + int dep_num, dep_count; + + dep_num = 0; + dep_count = unap_matrix[UNAPM_MIXED_EXPANDED][service_id][0]; + while (dep_num < dep_count) { + dep_num++; + if (unap_matrix[UNAPM_MIXED_EXPANDED][service_id][dep_num] == service_id) { + loopfound = solve_loop(unap_matrix, service_id, svc_id2depinfo_bt, dep_num, flags); + loopsolver_counter++; + break; + } + } + + service_id++; + } + } while (loopfound == LOOP_SOLVABLE && loopsolver_counter < LOOPSOLVER_LIMIT); + + if (loopsolver_counter >= LOOPSOLVER_LIMIT) + eerror("Dependency loop solver reached iterations limit."); + + /* clean up */ + + unapm_type = 0; + while (unapm_type < UNAPM_MAX) { + service_id=1; + while (service_id < (useneedafter_count+1)) + free(unap_matrix[unapm_type][service_id++]); + free(unap_matrix[unapm_type++]); + } + + tdestroy(svc_id2depinfo_bt, free); + } + + /* Phase 8 - save to disk Now that we're purely in C, do we need to keep a shell parseable file? I think yes as then it stays human readable This works and should be entirely shell parseable provided that depend --- a/src/librc/rc.h.in +++ b/src/librc/rc.h.in @@ -411,13 +411,26 @@ * @param deptree to free */ void rc_deptree_free(RC_DEPTREE *); +/*! @brief flags that may be passed to rc_deptree_update() */ +typedef enum +{ + + /* Enable dependency loop solver */ + RCDTFLAGS_LOOPSOLVER = 0x0001, + + /* Print warnings about found loops */ + RCDTFLAGS_LOOPSOLVER_WARNINGS = 0x0002, + +} RC_DT_FLAGS; + /*! Update the cached dependency tree if it's older than any init script, * its configuration file or an external configuration file the init script * has specified. * time_t returns the time of the newest file that the dependency tree * will be checked against. + * @param flags * @return true if successful, otherwise false */ -bool rc_deptree_update(void); +bool rc_deptree_update(RC_DT_FLAGS flags); /*! Check if the cached dependency tree is older than any init script, * its configuration file or an external configuration file the init script --- a/src/shared/misc.c +++ b/src/shared/misc.c @@ -382,7 +382,13 @@ if (regen) *regen = 1; ebegin("Caching service dependencies"); - retval = rc_deptree_update() ? 0 : -1; + + retval = rc_deptree_update( + (rc_conf_yesno("rc_loopsolver_enable" )?RCDTFLAGS_LOOPSOLVER :0) | + (rc_conf_yesno("rc_loopsolver_warnings")?RCDTFLAGS_LOOPSOLVER_WARNINGS :0) | + 0 + ) ? 0 : -1; + eend (retval, "Failed to update the dependency tree"); if (retval == 0) { --- /dev/null +++ b/test/units/solve_loop.c @@ -0,0 +1,175 @@ +/* +* unit test for the code of early loop detector (2014-01-27) +* Author: Dmitry Yu Okunev 0x8E30679C +*/ + +#include "../../src/librc/librc-depend.c" + +int main() { + service_id_t **unap_matrix[UNAPM_MAX], **unap_matrix_result[UNAPM_MAX]; + service_id_t service_id; + unapm_type_t unapm_type, type; + int useneedafter_count = 9; + int loopsolver_counter, loopfound, errfound; + char *service_id2str[] = { + [1] = "hwclock", + [2] = "mountall", + [3] = "mountall-bootclean", + [4] = "checkroot", + }; + char *deptype_id2str[] = { + [UNAPM_USE] = "use", + [UNAPM_AFTER] = "after", + [UNAPM_NEED] = "need", + }; + + unapm_type = 0; + while (unapm_type < UNAPM_MAX) { + unap_matrix[unapm_type] = xcalloc((useneedafter_count+1), sizeof(*unap_matrix)); + unap_matrix_result[unapm_type] = xcalloc((useneedafter_count+1), sizeof(*unap_matrix)); + service_id = 0; + while(service_id < (useneedafter_count+1)) { + unap_matrix [unapm_type][service_id] = xcalloc((useneedafter_count+1), sizeof(**unap_matrix)); + unap_matrix_result[unapm_type][service_id] = xcalloc((useneedafter_count+1), sizeof(**unap_matrix)); + service_id++; + } + unapm_type++; + } + + /* hwclock */ + unap_matrix[UNAPM_USE ][1][0] = 2; /* the count */ + unap_matrix[UNAPM_USE ][1][1] = 2; /* "mountall" */ + unap_matrix[UNAPM_USE ][1][2] = 3; /* "mountall-bootclean" */ + + /* mountall */ + unap_matrix[UNAPM_NEED ][2][0] = 1; /* the count */ + unap_matrix[UNAPM_NEED ][2][1] = 4; /* "checkroot" */ + + /* mountall-bootclean */ + unap_matrix[UNAPM_NEED ][3][0] = 1; /* the count */ + unap_matrix[UNAPM_NEED ][3][1] = 2; /* "mountall" */ + + /* checkroot */ + unap_matrix[UNAPM_AFTER][4][0] = 1; /* the count */ + unap_matrix[UNAPM_AFTER][4][1] = 1; /* "hwclock" */ + + unap_matrix[0][0][0] = 5; /* number of services+1 */ + + /* expected result */ + + unap_matrix_result[UNAPM_USE ][1][0] = 0; + + unap_matrix_result[UNAPM_NEED ][2][0] = 1; + unap_matrix_result[UNAPM_NEED ][2][1] = 4; + + unap_matrix_result[UNAPM_NEED ][3][0] = 1; + unap_matrix_result[UNAPM_NEED ][3][1] = 2; + + unap_matrix_result[UNAPM_AFTER][4][0] = 1; + unap_matrix_result[UNAPM_AFTER][4][1] = 1; + + /* solving */ + + loopsolver_counter = 0; + do { + loopfound = 0; + + unapm_prepare_mixed(unap_matrix, useneedafter_count); + + service_id=1; + while ((service_id < (useneedafter_count+1)) && !loopfound) { + int dep_num, dep_count; + + dep_num = 0; + dep_count = unap_matrix[UNAPM_MIXED_EXPANDED][service_id][0]; + while (dep_num < dep_count) { + dep_num++; + if (unap_matrix[UNAPM_MIXED_EXPANDED][service_id][dep_num] == service_id) { + loopfound = solve_loop(unap_matrix, service_id, NULL, dep_num, RCDTFLAGS_LOOPSOLVER); + loopsolver_counter++; + break; + } + } + + service_id++; + } + } while (loopfound == LOOP_SOLVABLE && loopsolver_counter < LOOPSOLVER_LIMIT); + /* don't free memory, it's just a unittest */ + + /* checking the result */ + + + errfound = 0; + type = 0; + while (type <= UNAPM_AFTER) { + service_id = 1; + while (service_id < (useneedafter_count+1)) { + int dep_count, dep_num; + + dep_num = 0; + dep_count = unap_matrix_result[type][service_id][0]; + + while (dep_num++ < dep_count) { + int dep_count2, dep_num2, found; + found = 0; + + dep_num2 = 0; + dep_count2 = unap_matrix[type][service_id][0]; + + while (dep_num2++ < dep_count2) + if ( + unap_matrix_result[type][service_id][dep_num] + == + unap_matrix [type][service_id][dep_num2] + ) { + found = 1; + break; + } + + if (!found) { + printf("unit-test: early loop detector: error: There's no \"%s\"\tdependency: %s -> %s\n", + deptype_id2str[type], + service_id2str[service_id], + service_id2str[unap_matrix_result[type][service_id][dep_num]] + ); + errfound = 1; + } + } + + dep_num = 0; + dep_count = unap_matrix[type][service_id][0]; + + while (dep_num++ < dep_count) { + int dep_count2, dep_num2, found; + found = 0; + + dep_num2 = 0; + dep_count2 = unap_matrix_result[type][service_id][0]; + + while (dep_num2++ < dep_count2) + if ( + unap_matrix_result[type][service_id][dep_num2] + == + unap_matrix [type][service_id][dep_num] + ) { + found = 1; + break; + } + + if (!found) { + printf("unit-test: early loop detector: error: There's extra \"%s\"\tdependency found: %s -> %s\n", + deptype_id2str[type], + service_id2str[service_id], + service_id2str[unap_matrix[type][service_id][dep_num]] + ); + errfound = 1; + } + } + + service_id++; + } + type++; + } + + return errfound != 0; +} --- a/src/librc/meson.build +++ b/src/librc/meson.build @@ -27,6 +27,7 @@ dependencies: kvm_dep, include_directories : [incdir, einfo_incdir], link_depends : 'rc.map', + link_with: [libeinfo], version : librc_version, install : true, install_dir : libdir) --- a/test/units/meson.build +++ b/test/units/meson.build @@ -1,5 +1,9 @@ is_older_than = find_program('check-is-older-than.sh') sh_yesno = find_program('check-sh-yesno.sh') +early_loop_detector = executable('early_loop_detector', 'solve_loop.c', + include_directories: [incdir, rc_incdir, einfo_incdir], + link_with: [librc, libeinfo]) test('is_older_than', is_older_than, env : test_env) test('sh_yesno', sh_yesno, env : test_env) +test('early_loop_detector', early_loop_detector, env : test_env)