int routing_policy_rule_get(Manager *m, int family, const union in_addr_union *from, uint8_t from_prefixlen, const union in_addr_union *to, uint8_t to_prefixlen, uint8_t tos, uint32_t fwmark, uint32_t table, char *iif, char *oif, RoutingPolicyRule **ret) { RoutingPolicyRule rule, *existing; assert_return(m, -1); rule = (RoutingPolicyRule) { .family = family, .from = *from, .from_prefixlen = from_prefixlen, .to = *to, .to_prefixlen = to_prefixlen, .tos = tos, .fwmark = fwmark, .table = table, .iif = iif, .oif = oif }; if (m->rules) { existing = set_get(m->rules, &rule); if (existing) { if (ret) *ret = existing; return 1; } } if (m->rules_foreign) { existing = set_get(m->rules_foreign, &rule); if (existing) { if (ret) *ret = existing; return 1; } } return -ENOENT; }
void TCP_Transporter::setSocketOptions(NDB_SOCKET_TYPE socket) { set_get(socket, SOL_SOCKET, SO_RCVBUF, "SO_RCVBUF", sockOptRcvBufSize); set_get(socket, SOL_SOCKET, SO_SNDBUF, "SO_SNDBUF", sockOptSndBufSize); set_get(socket, IPPROTO_TCP, TCP_NODELAY, "TCP_NODELAY", sockOptNodelay); set_get(socket, SOL_SOCKET, SO_KEEPALIVE, "SO_KEEPALIVE", 1); if (sockOptTcpMaxSeg) { #ifdef TCP_MAXSEG set_get(socket, IPPROTO_TCP, TCP_MAXSEG, "TCP_MAXSEG", sockOptTcpMaxSeg); #endif } }
range* rangefunc_has(range_request* rr, range** r) { range* ret = range_new(rr); apr_pool_t* pool = range_request_pool(rr); const char** tag_names = range_get_hostnames(pool, r[0]); const char** tag_values = range_get_hostnames(pool, r[1]); const char* tag_name = tag_names[0]; const char* tag_value = tag_values[0]; const char** all_clusters = _all_clusters(rr); const char** cluster = all_clusters; int warn_enabled = range_request_warn_enabled(rr); if (!cluster) return ret; range_request_disable_warns(rr); while (*cluster) { range* vals = _expand_cluster(rr, *cluster, tag_name); if (set_get(vals->nodes, tag_value) != NULL) { range_add(ret, *cluster); } cluster++; } if (warn_enabled) range_request_enable_warns(rr); return ret; }
range* rangefunc_mem(range_request* rr, range** r) { range* ret = range_new(rr); apr_pool_t* pool = range_request_pool(rr); const char** clusters = range_get_hostnames(pool, r[0]); const char* cluster = clusters[0]; const char** wanted = range_get_hostnames(pool, r[1]); range* keys = _expand_cluster(rr, cluster, "KEYS"); const char** all_sections = range_get_hostnames(pool, keys); const char** p_section = all_sections; SECTION: while (*p_section) { range* r_s = _expand_cluster(rr, cluster, *p_section); const char** p_wanted = wanted; while (*p_wanted) { if (set_get(r_s->nodes, *p_wanted) != NULL) { range_add(ret, *p_section++); goto SECTION; } ++p_wanted; } ++p_section; } return ret; }
static int unit_file_find_dirs( const char *original_root, Set *unit_path_cache, const char *unit_path, const char *name, const char *suffix, char ***dirs) { _cleanup_free_ char *prefix = NULL, *instance = NULL, *built = NULL; bool is_instance, chopped; const char *dash; UnitType type; char *path; size_t n; int r; assert(unit_path); assert(name); assert(suffix); path = strjoina(unit_path, "/", name, suffix); if (!unit_path_cache || set_get(unit_path_cache, path)) { r = unit_file_find_dir(original_root, path, dirs); if (r < 0) return r; } is_instance = unit_name_is_valid(name, UNIT_NAME_INSTANCE); if (is_instance) { /* Also try the template dir */ _cleanup_free_ char *template = NULL;
int unit_file_process_dir( Set *unit_path_cache, const char *unit_path, const char *name, const char *suffix, UnitDependency dependency, dependency_consumer_t consumer, void *arg, char ***strv) { _cleanup_free_ char *path = NULL; int r; assert(unit_path); assert(name); assert(suffix); path = strjoin(unit_path, "/", name, suffix); if (!path) return log_oom(); if (!unit_path_cache || set_get(unit_path_cache, path)) (void) iterate_dir(path, dependency, consumer, arg, strv); if (unit_name_is_valid(name, UNIT_NAME_INSTANCE)) { _cleanup_free_ char *template = NULL, *p = NULL;
void* libcrange_get_cache(libcrange* lr, const char* name) { set_element* se; if (lr == NULL) lr = get_static_lr(); if ((se = set_get(lr->caches, name))) return se->data; else return NULL; }
static bool unix_socket_alive(const char *fn) { assert(fn); load_unix_sockets(); if (unix_sockets) return !!set_get(unix_sockets, (char*) fn); /* We don't know, so assume yes */ return true; }
int TCP_Transporter::pre_connect_options(NDB_SOCKET_TYPE sockfd) { if (sockOptTcpMaxSeg) { #ifdef TCP_MAXSEG set_get(sockfd, IPPROTO_TCP, TCP_MAXSEG, "TCP_MAXSEG", sockOptTcpMaxSeg); #endif } return 0; }
static int field_set_test(Set *fields, const char *name, size_t n) { char *s = NULL; if (!fields) return 1; s = strndupa(name, n); if (!s) return log_oom(); return set_get(fields, s) ? 1 : 0; }
int route_get(Link *link, int family, const union in_addr_union *dst, unsigned char dst_prefixlen, unsigned char tos, uint32_t priority, unsigned char table, Route **ret) { Route route, *existing; assert(link); assert(dst); route = (Route) { .family = family, .dst = *dst, .dst_prefixlen = dst_prefixlen, .tos = tos, .priority = priority, .table = table, }; existing = set_get(link->routes, &route); if (existing) { if (ret) *ret = existing; return 1; } existing = set_get(link->routes_foreign, &route); if (existing) { if (ret) *ret = existing; return 0; } return -ENOENT; }
static int test_BN_set_get(void) { int ret = 0; CHECK(set_get(0)); CHECK(set_get(1)); CHECK(set_get(0xff)); CHECK(set_get(0x1ff)); CHECK(set_get(0xffff)); CHECK(set_get(0xf000)); CHECK(set_get(ULONG_MAX / 2)); CHECK(set_get(ULONG_MAX - 1)); return ret; }
static void run_test(const char *file, size_t r, unsigned int size, unsigned int mode) { FILE *fp; char buffer[512]; size_t i, j; unsigned int d = 0; uint64_t s, e, a, ri, si, ai, sr, rg, sg, ag, sd, ng, ss, sts, su, sgc, sb; struct ck_hs_stat st; char **t; keys = malloc(sizeof(char *) * keys_capacity); assert(keys != NULL); fp = fopen(file, "r"); assert(fp != NULL); while (fgets(buffer, sizeof(buffer), fp) != NULL) { buffer[strlen(buffer) - 1] = '\0'; keys[keys_length++] = strdup(buffer); assert(keys[keys_length - 1] != NULL); if (keys_length == keys_capacity) { t = realloc(keys, sizeof(char *) * (keys_capacity *= 2)); assert(t != NULL); keys = t; } } t = realloc(keys, sizeof(char *) * keys_length); assert(t != NULL); keys = t; set_init(size, mode); for (i = 0; i < keys_length; i++) d += set_insert(keys[i]) == false; ck_hs_stat(&hs, &st); fprintf(stderr, "# %zu entries stored, %u duplicates, %u probe.\n", set_count(), d, st.probe_maximum); a = 0; for (j = 0; j < r; j++) { if (set_reset() == false) { ck_error("ERROR: Failed to reset hash table.\n"); } s = rdtsc(); for (i = keys_length; i > 0; i--) d += set_insert(keys[i - 1]) == false; e = rdtsc(); a += e - s; } ri = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { if (set_reset() == false) { ck_error("ERROR: Failed to reset hash table.\n"); } s = rdtsc(); for (i = 0; i < keys_length; i++) d += set_insert(keys[i]) == false; e = rdtsc(); a += e - s; } si = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { keys_shuffle(keys); if (set_reset() == false) { ck_error("ERROR: Failed to reset hash table.\n"); } s = rdtsc(); for (i = 0; i < keys_length; i++) d += set_insert(keys[i]) == false; e = rdtsc(); a += e - s; } ai = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { s = rdtsc(); for (i = 0; i < keys_length; i++) set_swap(keys[i]); e = rdtsc(); a += e - s; } ss = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { s = rdtsc(); for (i = 0; i < keys_length; i++) set_replace(keys[i]); e = rdtsc(); a += e - s; } sr = a / (r * keys_length); set_reset(); for (i = 0; i < keys_length; i++) set_insert(keys[i]); a = 0; for (j = 0; j < r; j++) { s = rdtsc(); for (i = keys_length; i > 0; i--) { if (set_get(keys[i - 1]) == NULL) { ck_error("ERROR: Unexpected NULL value.\n"); } } e = rdtsc(); a += e - s; } rg = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { s = rdtsc(); for (i = 0; i < keys_length; i++) { if (set_get(keys[i]) == NULL) { ck_error("ERROR: Unexpected NULL value.\n"); } } e = rdtsc(); a += e - s; } sg = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { keys_shuffle(keys); s = rdtsc(); for (i = 0; i < keys_length; i++) { if (set_get(keys[i]) == NULL) { ck_error("ERROR: Unexpected NULL value.\n"); } } e = rdtsc(); a += e - s; } ag = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { s = rdtsc(); for (i = 0; i < keys_length; i++) set_remove(keys[i]); e = rdtsc(); a += e - s; for (i = 0; i < keys_length; i++) set_insert(keys[i]); } sd = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { s = rdtsc(); for (i = 0; i < keys_length; i++) { set_get("\x50\x03\x04\x05\x06\x10"); } e = rdtsc(); a += e - s; } ng = a / (r * keys_length); set_reset(); for (i = 0; i < keys_length; i++) set_insert(keys[i]); for (i = 0; i < keys_length; i++) set_remove(keys[i]); a = 0; for (j = 0; j < r; j++) { s = rdtsc(); for (i = 0; i < keys_length; i++) set_insert(keys[i]); e = rdtsc(); a += e - s; for (i = 0; i < keys_length; i++) set_remove(keys[i]); } sts = a / (r * keys_length); set_reset(); /* Prune duplicates. */ for (i = 0; i < keys_length; i++) { if (set_insert(keys[i]) == true) continue; free(keys[i]); keys[i] = keys[--keys_length]; } for (i = 0; i < keys_length; i++) set_remove(keys[i]); a = 0; for (j = 0; j < r; j++) { s = rdtsc(); for (i = 0; i < keys_length; i++) set_insert_unique(keys[i]); e = rdtsc(); a += e - s; for (i = 0; i < keys_length; i++) set_remove(keys[i]); } su = a / (r * keys_length); for (i = 0; i < keys_length; i++) set_insert_unique(keys[i]); for (i = 0; i < keys_length / 2; i++) set_remove(keys[i]); a = 0; for (j = 0; j < r; j++) { s = rdtsc(); set_gc(); e = rdtsc(); a += e - s; } sgc = a / r; a = 0; for (j = 0; j < r; j++) { s = rdtsc(); set_rebuild(); e = rdtsc(); a += e - s; } sb = a / r; printf("%zu " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 "\n", keys_length, ri, si, ai, ss, sr, rg, sg, ag, sd, ng, sts, su, sgc, sb); fclose(fp); for (i = 0; i < keys_length; i++) { free(keys[i]); } free(keys); keys_length = 0; set_destroy(); return; }
bool fdset_contains(FDSet *s, int fd) { assert(s); assert(fd >= 0); return !!set_get(MAKE_SET(s), FD_TO_PTR(fd)); }
int main(int argc, char *argv[]) { FILE *fp; char buffer[512]; size_t i, j, r; unsigned int d = 0; uint64_t s, e, a, ri, si, ai, sr, rg, sg, ag, sd, ng; struct ck_hs_stat st; char **t; r = 20; s = 8; srand(time(NULL)); if (argc < 2) { ck_error("Usage: ck_hs <dictionary> [<repetitions> <initial size>]\n"); } if (argc >= 3) r = atoi(argv[2]); if (argc >= 4) s = (uint64_t)atoi(argv[3]); keys = malloc(sizeof(char *) * keys_capacity); assert(keys != NULL); fp = fopen(argv[1], "r"); assert(fp != NULL); while (fgets(buffer, sizeof(buffer), fp) != NULL) { buffer[strlen(buffer) - 1] = '\0'; keys[keys_length++] = strdup(buffer); assert(keys[keys_length - 1] != NULL); if (keys_length == keys_capacity) { t = realloc(keys, sizeof(char *) * (keys_capacity *= 2)); assert(t != NULL); keys = t; } } t = realloc(keys, sizeof(char *) * keys_length); assert(t != NULL); keys = t; set_init(); for (i = 0; i < keys_length; i++) d += set_insert(keys[i]) == false; ck_hs_stat(&hs, &st); fprintf(stderr, "# %zu entries stored, %u duplicates, %u probe.\n", set_count(), d, st.probe_maximum); fprintf(stderr, "# reverse_insertion serial_insertion random_insertion serial_replace reverse_get serial_get random_get serial_remove negative_get\n\n"); a = 0; for (j = 0; j < r; j++) { if (set_reset() == false) { ck_error("ERROR: Failed to reset hash table.\n"); } s = rdtsc(); for (i = keys_length; i > 0; i--) d += set_insert(keys[i - 1]) == false; e = rdtsc(); a += e - s; } ri = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { if (set_reset() == false) { ck_error("ERROR: Failed to reset hash table.\n"); } s = rdtsc(); for (i = 0; i < keys_length; i++) d += set_insert(keys[i]) == false; e = rdtsc(); a += e - s; } si = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { keys_shuffle(keys); if (set_reset() == false) { ck_error("ERROR: Failed to reset hash table.\n"); } s = rdtsc(); for (i = 0; i < keys_length; i++) d += set_insert(keys[i]) == false; e = rdtsc(); a += e - s; } ai = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { s = rdtsc(); for (i = 0; i < keys_length; i++) set_replace(keys[i]); e = rdtsc(); a += e - s; } sr = a / (r * keys_length); set_reset(); for (i = 0; i < keys_length; i++) set_insert(keys[i]); a = 0; for (j = 0; j < r; j++) { s = rdtsc(); for (i = keys_length; i > 0; i--) { if (set_get(keys[i - 1]) == NULL) { ck_error("ERROR: Unexpected NULL value.\n"); } } e = rdtsc(); a += e - s; } rg = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { s = rdtsc(); for (i = 0; i < keys_length; i++) { if (set_get(keys[i]) == NULL) { ck_error("ERROR: Unexpected NULL value.\n"); } } e = rdtsc(); a += e - s; } sg = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { keys_shuffle(keys); s = rdtsc(); for (i = 0; i < keys_length; i++) { if (set_get(keys[i]) == NULL) { ck_error("ERROR: Unexpected NULL value.\n"); } } e = rdtsc(); a += e - s; } ag = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { s = rdtsc(); for (i = 0; i < keys_length; i++) set_remove(keys[i]); e = rdtsc(); a += e - s; for (i = 0; i < keys_length; i++) set_insert(keys[i]); } sd = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { s = rdtsc(); for (i = 0; i < keys_length; i++) { set_get("\x50\x03\x04\x05\x06\x10"); } e = rdtsc(); a += e - s; } ng = a / (r * keys_length); printf("%zu " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 "\n", keys_length, ri, si, ai, sr, rg, sg, ag, sd, ng); return 0; }
int cg_migrate(const char *controller, const char *from, const char *to, bool ignore_self) { bool done = false; Set *s; int r, ret = 0; pid_t my_pid; FILE *f = NULL; assert(controller); assert(from); assert(to); if (!(s = set_new(trivial_hash_func, trivial_compare_func))) return -ENOMEM; my_pid = getpid(); do { pid_t pid = 0; done = true; if ((r = cg_enumerate_tasks(controller, from, &f)) < 0) { if (ret >= 0 && r != -ENOENT) ret = r; goto finish; } while ((r = cg_read_pid(f, &pid)) > 0) { /* This might do weird stuff if we aren't a * single-threaded program. However, we * luckily know we are not */ if (pid == my_pid && ignore_self) continue; if (set_get(s, LONG_TO_PTR(pid)) == LONG_TO_PTR(pid)) continue; if ((r = cg_attach(controller, to, pid)) < 0) { if (ret >= 0 && r != -ESRCH) ret = r; } else if (ret == 0) ret = 1; done = false; if ((r = set_put(s, LONG_TO_PTR(pid))) < 0) { if (ret >= 0) ret = r; goto finish; } } if (r < 0) { if (ret >= 0) ret = r; goto finish; } fclose(f); f = NULL; } while (!done); finish: set_free(s); if (f) fclose(f); return ret; }
int cg_kill(const char *controller, const char *path, int sig, bool sigcont, bool ignore_self, Set *s) { bool done = false; int r, ret = 0; pid_t my_pid; FILE *f = NULL; Set *allocated_set = NULL; assert(controller); assert(path); assert(sig >= 0); /* This goes through the tasks list and kills them all. This * is repeated until no further processes are added to the * tasks list, to properly handle forking processes */ if (!s) if (!(s = allocated_set = set_new(trivial_hash_func, trivial_compare_func))) return -ENOMEM; my_pid = getpid(); do { pid_t pid = 0; done = true; if ((r = cg_enumerate_processes(controller, path, &f)) < 0) { if (ret >= 0 && r != -ENOENT) ret = r; goto finish; } while ((r = cg_read_pid(f, &pid)) > 0) { if (pid == my_pid && ignore_self) continue; if (set_get(s, LONG_TO_PTR(pid)) == LONG_TO_PTR(pid)) continue; /* If we haven't killed this process yet, kill * it */ if (kill(pid, sig) < 0) { if (ret >= 0 && errno != ESRCH) ret = -errno; } else if (ret == 0) { if (sigcont) kill(pid, SIGCONT); ret = 1; } done = false; if ((r = set_put(s, LONG_TO_PTR(pid))) < 0) { if (ret >= 0) ret = r; goto finish; } } if (r < 0) { if (ret >= 0) ret = r; goto finish; } fclose(f); f = NULL; /* To avoid racing against processes which fork * quicker than we can kill them we repeat this until * no new pids need to be killed. */ } while (!done); finish: if (allocated_set) set_free(allocated_set); if (f) fclose(f); return ret; }
void setup() { ::setup(); action_pri = 3; reset_drop(); set_get(); } /* setup() */
static void ndisc_router_process_rdnss(Link *link, sd_ndisc_router *rt) { uint32_t lifetime; const struct in6_addr *a; usec_t time_now; int i, n, r; assert(link); assert(rt); r = sd_ndisc_router_get_timestamp(rt, clock_boottime_or_monotonic(), &time_now); if (r < 0) { log_link_warning_errno(link, r, "Failed to get RA timestamp: %m"); return; } r = sd_ndisc_router_rdnss_get_lifetime(rt, &lifetime); if (r < 0) { log_link_warning_errno(link, r, "Failed to get RDNSS lifetime: %m"); return; } n = sd_ndisc_router_rdnss_get_addresses(rt, &a); if (n < 0) { log_link_warning_errno(link, n, "Failed to get RDNSS addresses: %m"); return; } for (i = 0; i < n; i++) { NDiscRDNSS d = { .address = a[i] }, *x; if (lifetime == 0) { (void) set_remove(link->ndisc_rdnss, &d); link_dirty(link); continue; } x = set_get(link->ndisc_rdnss, &d); if (x) { x->valid_until = time_now + lifetime * USEC_PER_SEC; continue; } ndisc_vacuum(link); if (set_size(link->ndisc_rdnss) >= NDISC_RDNSS_MAX) { log_link_warning(link, "Too many RDNSS records per link, ignoring."); continue; } r = set_ensure_allocated(&link->ndisc_rdnss, &ndisc_rdnss_hash_ops); if (r < 0) { log_oom(); return; } x = new0(NDiscRDNSS, 1); if (!x) { log_oom(); return; } x->address = a[i]; x->valid_until = time_now + lifetime * USEC_PER_SEC; r = set_put(link->ndisc_rdnss, x); if (r < 0) { free(x); log_oom(); return; } assert(r > 0); link_dirty(link); }
int cg_kill(const char *controller, const char *path, int sig, bool sigcont, bool ignore_self, Set *s) { _cleanup_set_free_ Set *allocated_set = NULL; bool done = false; int r, ret = 0; pid_t my_pid; assert(sig >= 0); /* This goes through the tasks list and kills them all. This * is repeated until no further processes are added to the * tasks list, to properly handle forking processes */ if (!s) { s = allocated_set = set_new(NULL); if (!s) return -ENOMEM; } my_pid = getpid(); do { _cleanup_fclose_ FILE *f = NULL; pid_t pid = 0; done = true; r = cg_enumerate_processes(controller, path, &f); if (r < 0) { if (ret >= 0 && r != -ENOENT) return r; return ret; } while ((r = cg_read_pid(f, &pid)) > 0) { if (ignore_self && pid == my_pid) continue; if (set_get(s, LONG_TO_PTR(pid)) == LONG_TO_PTR(pid)) continue; /* If we haven't killed this process yet, kill * it */ if (kill(pid, sig) < 0) { if (ret >= 0 && errno != ESRCH) ret = -errno; } else { if (sigcont && sig != SIGKILL) kill(pid, SIGCONT); if (ret == 0) ret = 1; } done = false; r = set_put(s, LONG_TO_PTR(pid)); if (r < 0) { if (ret >= 0) return r; return ret; } } if (r < 0) { if (ret >= 0) return r; return ret; } /* To avoid racing against processes which fork * quicker than we can kill them we repeat this until * no new pids need to be killed. */ } while (!done); return ret; }
void ProcList::displayList() { theMainWin->setProgress(L"Saving list state..."); std::unordered_map<Database::Address, int> item_state; // TODO: use GetNextItem? for (long i=0; i<GetItemCount(); i++) if (int state = GetItemState(i, wxLIST_STATE_FOCUSED|wxLIST_STATE_SELECTED)) item_state[GetItemData(i)] = state; theMainWin->setProgress(L"Clearing list..."); Freeze(); DeleteAllItems(); theMainWin->setProgress(L"Populating list...", list.items.size()); const ViewState *viewstate = theMainWin->getViewState(); for (auto i = list.items.begin(); i != list.items.end(); ++i) { const Database::Symbol *sym = i->symbol; if (isroot && set_get(viewstate->filtered, sym->address)) continue; long c = GetItemCount(); wxListItem item; item.SetId(c); item.SetText(sym->procname); if (sym->isCollapseFunction || sym->isCollapseModule) item.SetTextColour(wxColor(0,128,0)); if (set_get(viewstate->highlighted, sym->address)) item.SetBackgroundColour(wxColor(255,255,0)); int state = map_get(item_state, sym->address, 0); item.SetData(sym->address); item.SetState(state); item.SetStateMask(wxLIST_STATE_FOCUSED|wxLIST_STATE_SELECTED); InsertItem(item); wxString inclusive = wxString::Format("%0.2fs", i->inclusive); wxString exclusive = wxString::Format("%0.2fs", i->exclusive); wxString inclusivepercent = wxString::Format("%0.2f%%", i->inclusive * 100.0f / list.totalcount); wxString exclusivepercent = wxString::Format("%0.2f%%", i->exclusive * 100.0f / list.totalcount); setColumnValue(c, COL_EXCLUSIVE, exclusive); setColumnValue(c, COL_INCLUSIVE, inclusive); setColumnValue(c, COL_EXCLUSIVEPCT, exclusivepercent); setColumnValue(c, COL_INCLUSIVEPCT, inclusivepercent); setColumnValue(c, COL_SAMPLES, exclusive); setColumnValue(c, COL_CALLSPCT, exclusivepercent); setColumnValue(c, COL_MODULE, database->getModuleName(sym->module)); setColumnValue(c, COL_SOURCEFILE, database->getFileName (sym->sourcefile)); setColumnValue(c, COL_SOURCELINE, ::toString((int)database->getAddrInfo(i->address)->sourceline)); setColumnValue(c, COL_ADDRESS, ::toHexString(i->address)); if (state & wxLIST_STATE_FOCUSED) EnsureVisible(c); theMainWin->updateProgress(i-list.items.begin()); } Thaw(); theMainWin->setProgress(NULL); }
static set* _cluster_keys(range_request* rr, apr_pool_t* pool, const char* cluster, const char* cluster_file) { char line[32768]; char* p; int ovector[30]; apr_array_header_t* working_range; set* sections; char* section; char* cur_section; apr_pool_t* req_pool = range_request_pool(rr); int line_no; FILE* fp = fopen(cluster_file, "r"); if (!fp) { range_request_warn(rr, "%s: %s not readable", cluster, cluster_file); return set_new(pool, 0); } if (!include_re) { const char* error; include_re = pcre_compile(INCLUDE_RE, 0, &error, ovector, NULL); assert(include_re); exclude_re = pcre_compile(EXCLUDE_RE, 0, &error, ovector, NULL); assert(exclude_re); } sections = set_new(pool, 0); section = cur_section = NULL; working_range = apr_array_make(req_pool, 1, sizeof(char*)); line_no = 0; while (fgets(line, sizeof line, fp)) { int len; int count; line_no++; line[sizeof line - 1] = '\0'; len = strlen(line); if (len+1 >= sizeof(line) && line[len - 1] != '\n') { /* incomplete line */ fprintf(stderr, "%s:%d lines > 32767 chars not supported\n", cluster_file, line_no); exit(-1); } line[--len] = '\0'; /* get rid of the \n */ for (p = line; *p; ++p) if (*p == '#') { *p = '\0'; break; } len = strlen(line); if (len == 0) continue; for (p = &line[len - 1]; isspace(*p); --p) { *p = '\0'; --len; } if (!*line) continue; if (!(isspace(*line))) { cur_section = apr_pstrdup(pool, line); continue; } if (section && strcmp(cur_section, section) != 0) { set_add(sections, section, apr_array_pstrcat(pool, working_range, ',')); working_range = apr_array_make(req_pool, 1, sizeof(char*)); } section = cur_section; count = pcre_exec(include_re, NULL, line, len, 0, 0, ovector, 30); if (count > 0) { line[ovector[3]] = '\0'; *(char**)apr_array_push(working_range) = apr_psprintf(pool, "(%s)", _substitute_dollars(pool, cluster, &line[ovector[2]])); continue; } count = pcre_exec(exclude_re, NULL, line, len, 0, 0, ovector, 30); if (count > 0) { line[ovector[3]] = '\0'; *(char**)apr_array_push(working_range) = apr_psprintf(pool, "-(%s)", _substitute_dollars(pool, cluster, &line[ovector[2]])); } } fclose(fp); if (cur_section) set_add(sections, cur_section, apr_array_pstrcat(pool, working_range, ',')); set_add(sections, "KEYS", _join_elements(pool, ',', sections)); set_add(sections, "UP", set_get_data(sections, "CLUSTER")); if (set_get(sections, "ALL") && set_get(sections, "CLUSTER")) set_add(sections, "DOWN", apr_psprintf(pool, "(%s)-(%s)", (char*)set_get_data(sections, "ALL"), (char*)set_get_data(sections, "CLUSTER"))); return sections; }
void draw_settings(BWAnal *aa) { int xx= d_set_xx; int yy= d_set_yy; int sx= d_set_sx; int sy= d_set_sy; int fsx= s_font ? 8 : 6; int cyy; int set; char ch; char buf[10]; clear_rect(xx, yy, sx, sy, colour[0]); // Display logo or current setting value if (c_set < 0) { int sy2= 2 * disp_font; int x, y; for (y= 0; y<sy2; y++) for (x= 0; x<sx; x++) { double fx= (0.5 + x - sx/2) / sy2; double fy= (0.5 + y - sy2/2) / sy2; double mag= hypot(fx, fy); double pha= atan2(fx, fy) / 2 / M_PI; plot_hue(xx+x, yy+y, 1, 0.8 - 0.5 / (1 + mag*1), pha - mag * 0.8 + 0.088); } drawtext(disp_font, xx, yy + disp_font/2, "\x94" "BWView"); } else { int pre; int mox= sx - (s_font ? 8 : 6) * 2; // Maximum offset-X buf[0]= '\x98'; buf[1]= set_codes[c_set]; buf[2]= pre= s_preset[c_set]; buf[3]= 0; if (!isdigit(pre)) { double fp= set_get(aa, c_set); for (pre= 1; pre < 10; pre++) if (fp >= set_preset_values[c_set][pre] && fp <= set_preset_values[c_set][(pre+1)%10]) break; } else if (pre == '0') pre= 10; else pre= (pre-'0'); drawtext(disp_font, xx + mox * (pre-1) / 9, yy, buf); buf[0]= '\x8C'; set_format(aa, c_set, buf+1); drawtext(disp_font, xx, yy + disp_font, buf); } // Draw main display of settings for (set= 0; ch= set_codes[set]; set++) { cyy= yy + (set/2 + 3) * disp_font; if (set == c_set) drawtext(disp_font, xx + (set&1)*fsx*3, cyy, "\x91 "); buf[0]= ch; buf[1]= s_preset[set]; buf[2]= 0; drawtext(disp_font, xx + (set&1)*fsx*3 + fsx/2, cyy, buf); } update(xx, yy, sx, sy); }
Route **ret) { Route route = { .family = family, .dst_prefixlen = dst_prefixlen, .tos = tos, .priority = priority, .table = table, }, *existing; assert(link); assert(dst); assert(ret); route.dst = *dst; existing = set_get(link->routes, &route); if (existing) { *ret = existing; return 1; } else { existing = set_get(link->routes_foreign, &route); if (!existing) return -ENOENT; } *ret = existing; return 0; } static int route_add_internal(Link *link, Set **routes,
int cg_migrate(const char *cfrom, const char *pfrom, const char *cto, const char *pto, bool ignore_self) { bool done = false; _cleanup_set_free_ Set *s = NULL; int r, ret = 0; pid_t my_pid; _cleanup_fclose_ FILE *f = NULL; assert(cfrom); assert(pfrom); assert(cto); assert(pto); s = set_new(trivial_hash_func, trivial_compare_func); if (!s) return -ENOMEM; my_pid = getpid(); do { pid_t pid = 0; done = true; r = cg_enumerate_tasks(cfrom, pfrom, &f); if (r < 0) { if (ret >= 0 && r != -ENOENT) ret = r; return ret; } while ((r = cg_read_pid(f, &pid)) > 0) { /* This might do weird stuff if we aren't a * single-threaded program. However, we * luckily know we are not */ if (pid == my_pid && ignore_self) continue; if (set_get(s, LONG_TO_PTR(pid)) == LONG_TO_PTR(pid)) continue; r = cg_attach(cto, pto, pid); if (r < 0) { if (ret >= 0 && r != -ESRCH) ret = r; } else if (ret == 0) ret = 1; done = false; r = set_put(s, LONG_TO_PTR(pid)); if (r < 0) { if (ret >= 0) ret = r; return ret; } } if (r < 0) { if (ret >= 0) ret = r; return ret; } fclose(f); f = NULL; } while (!done); return ret; }