static void search_item(TableIndex index, void *key_ptr, int key_len, void *info_ptr, void *arg) { LoaderInfo *info; SearchData *data; HPROF_ASSERT(info_ptr!=NULL); HPROF_ASSERT(arg!=NULL); info = (LoaderInfo*)info_ptr; data = (SearchData*)arg; if ( data->loader == info->globalref ) { /* Covers when looking for NULL too. */ HPROF_ASSERT(data->found==0); /* Did we find more than one? */ data->found = index; } else if ( data->env != NULL && data->loader != NULL && info->globalref != NULL ) { jobject lref; lref = newLocalReference(data->env, info->globalref); if ( lref == NULL ) { /* Object went away, free reference and entry */ free_entry(data->env, index); } else if ( isSameObject(data->env, data->loader, lref) ) { HPROF_ASSERT(data->found==0); /* Did we find more than one? */ data->found = index; } if ( lref != NULL ) { deleteLocalReference(data->env, lref); } } }
/** * Creates a new cache entry and then puts it into the cache's hashtable. * * @param peer_id the index of the peer to tag the newly created entry * @return the newly created entry */ static struct CacheEntry * add_entry (unsigned int peer_id) { struct CacheEntry *entry; GNUNET_assert (NULL != cache); if (cache_size == GNUNET_CONTAINER_multihashmap32_size (cache)) { /* remove the LRU head */ entry = cache_head; GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap32_remove (cache, (uint32_t) entry->peer_id, entry)); free_entry (entry); } entry = GNUNET_new (struct CacheEntry); entry->peer_id = peer_id; GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap32_put (cache, (uint32_t) peer_id, entry, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)); GNUNET_CONTAINER_DLL_insert_tail (cache_head, cache_tail, entry); return entry; }
int push_to_dirstack(const char *ld, const char *lf, const char *rd, const char *rf) { if(stack_top == stack_size) { stack_entry_t *s = reallocarray(stack, stack_size + 1, sizeof(*stack)); if(s == NULL) { return -1; } stack = s; stack_size++; } stack[stack_top].lpane_dir = strdup(ld); stack[stack_top].lpane_file = strdup(lf); stack[stack_top].rpane_dir = strdup(rd); stack[stack_top].rpane_file = strdup(rf); if(stack[stack_top].lpane_dir == NULL || stack[stack_top].lpane_file == NULL || stack[stack_top].rpane_dir == NULL || stack[stack_top].rpane_file == NULL) { free_entry(&stack[stack_top]); return -1; } stack_top++; changed = 1; return 0; }
void mark_deleted_entry( struct entry_t * entry ) { free_entry( entry ); int total_size = entry->word_len + entry->content_len; entry->word_len = 0; entry->content_len = total_size; }
static void pwdfile_search( struct ldop *op, FILE *ofp ) { struct passwd *pw; struct ldentry *entry; int oneentry; oneentry = ( strchr( op->ldop_dn, '@' ) != NULL ); for ( pw = getpwent(); pw != NULL; pw = getpwent()) { if (( entry = pw2entry( op, pw )) != NULL ) { if ( oneentry ) { if ( strcasecmp( op->ldop_dn, entry->lde_dn ) == 0 ) { write_entry( op, entry, ofp ); break; } } else if ( test_filter( op, entry ) == LDAP_COMPARE_TRUE ) { write_entry( op, entry, ofp ); } free_entry( entry ); } } endpwent(); write_result( ofp, LDAP_SUCCESS, NULL, NULL ); }
/** * Clears expired entries in the ARP table. * * This function should be called every ETHARP_TMR_INTERVAL milliseconds (5 seconds), * in order to expire entries in the ARP table. */ void etharp_tmr(void) { u8_t i; LWIP_DEBUGF(ETHARP_DEBUG, ("etharp_timer\n")); /* remove expired entries from the ARP table */ for (i = 0; i < ARP_TABLE_SIZE; ++i) { u8_t state = arp_table[i].state; if (state != ETHARP_STATE_EMPTY #if ETHARP_SUPPORT_STATIC_ENTRIES && (arp_table[i].static_entry == 0) #endif /* ETHARP_SUPPORT_STATIC_ENTRIES */ ) { arp_table[i].ctime++; if ((arp_table[i].ctime >= ARP_MAXAGE) || ((arp_table[i].state == ETHARP_STATE_PENDING) && (arp_table[i].ctime >= ARP_MAXPENDING))) { /* pending or stable entry has become old! */ LWIP_DEBUGF(ETHARP_DEBUG, ("etharp_timer: expired %s entry %"U16_F".\n", arp_table[i].state == ETHARP_STATE_STABLE ? "stable" : "pending", (u16_t)i)); /* clean up entries that have just been expired */ free_entry(i); } #if ARP_QUEUEING /* still pending entry? (not expired) */ if (arp_table[i].state == ETHARP_STATE_PENDING) { /* resend an ARP query here? */ } #endif /* ARP_QUEUEING */ } } }
void free_hash(h_entry_t* hash, unsigned int hash_size, int do_cell) { int i; /* index for hash entries */ entry_t *tmp, /* just a temporar variable */ *it; /* iterator through cells of a has entry */ if(!hash || hash_size<=0) return; /* free memory ocupied by all hash entries */ for(i=0; i<hash_size; i++) { /* iterator through the i-th entry of the hash */ it = hash[i].e; /* as long as we have a cell */ while(it != NULL) { /* retains the next cell */ tmp = it->n; free_entry(it, do_cell); /* the iterator points up to the next cell */ it = tmp; } lock_destroy(&hash[i].lock); } shm_free(hash); }
static int demote_cblock(struct smq_policy *mq, struct policy_locker *locker, dm_oblock_t *oblock) { struct entry *demoted = q_peek(&mq->clean, mq->clean.nr_levels, false); if (!demoted) /* * We could get a block from mq->dirty, but that * would add extra latency to the triggering bio as it * waits for the writeback. Better to not promote this * time and hope there's a clean block next time this block * is hit. */ return -ENOSPC; if (locker->fn(locker, demoted->oblock)) /* * We couldn't lock this block. */ return -EBUSY; del(mq, demoted); *oblock = demoted->oblock; free_entry(&mq->cache_alloc, demoted); return 0; }
void CLIB_DECL free(void *memory) { memory_entry *entry; // allow NULL frees if (memory == NULL) return; // error if no entry found entry = find_entry(memory); if (entry == NULL) { if (winalloc_in_main_code) { fprintf(stderr, "Error: free a non-existant block\n"); osd_break_into_debugger("Error: free a non-existant block"); } return; } free_entry(entry); // free the memory if (USE_GUARD_PAGES) VirtualFree((UINT8 *)memory - ((UINT32)memory & (PAGE_SIZE-1)) - PAGE_SIZE, 0, MEM_RELEASE); else GlobalFree(memory); #if LOG_CALLS logerror("free #%06d size = %d\n", entry->id, entry->size); #endif }
static inline void __noinstrument do_func_exit(struct kfi_run* run, void *this_fn, void *call_site) { struct kfi_entry* entry; unsigned long exittime; unsigned long delta; int entry_i; if ((entry_i = find_entry(run, this_fn, in_interrupt() ? INTR_CONTEXT : current->pid)) < 0) { #ifdef KFI_DEBUG run->notfound++; #endif return; } entry = &run->log[entry_i]; // calc delta exittime = update_usecs_since_boot() - run->start_trigger.mark; delta = exittime - entry->time; if ((run->filters.min_delta && delta < run->filters.min_delta) || (run->filters.max_delta && delta > run->filters.max_delta)) { #ifdef KFI_DEBUG run->filters.cnt.delta++; #endif free_entry(run, entry_i); } else { entry->delta = delta; } }
/* * Check the sigq for any pending signals. If any are found, * preform the required actions and remove them from the queue. */ PUBLIC void sig_check(void) { q_entry_t *e; sigset_t nset; sigset_t oset; void (*handler)(int); int signo; (void)sigfillset(&nset); (void)sigprocmask(SIG_SETMASK, &nset, &oset); while ((e = sigq.qe_first) != NULL) { signo = e->qe_signo; handler = e->qe_handler; /* * Remove the entry from the queue and free it. */ sigq.qe_first = e->qe_next; if (sigq.qe_first == NULL) sigq.qe_last = &sigq.qe_first; free_entry(e); if (handler == SIG_DFL || handler == SIG_IGN) { assert(/*CONSTCOND*/ 0); /* These should not get posted. */ } else { (void)sigprocmask(SIG_SETMASK, &oset, NULL); handler(signo); (void)sigprocmask(SIG_SETMASK, &nset, NULL); } } (void)sigprocmask(SIG_SETMASK, &oset, NULL); }
/* We `seal' the path by linking everything into one big list. Then we provide a way to iterate through the sealed list. If PRINT is true then we print the final class path to stderr. */ void jcf_path_seal (int print) { struct entry *secondary; sealed = include_dirs; include_dirs = NULL; if (classpath_user) { secondary = classpath_user; classpath_user = NULL; } else { if (! classpath_env) add_entry (&classpath_env, ".", 0); secondary = classpath_env; classpath_env = NULL; } free_entry (&classpath_user); free_entry (&classpath_env); append_entry (&sealed, secondary); append_entry (&sealed, sys_dirs); append_entry (&sealed, extensions); sys_dirs = NULL; extensions = NULL; if (print) { struct entry *ent; fprintf (stderr, "Class path starts here:\n"); for (ent = sealed; ent; ent = ent->next) { fprintf (stderr, " %s", ent->name); if ((ent->flags & FLAG_SYSTEM)) fprintf (stderr, " (system)"); if ((ent->flags & FLAG_ZIP)) fprintf (stderr, " (zip)"); fprintf (stderr, "\n"); } } }
void clean_stack(void) { while(stack_top > 0) { free_entry(&stack[--stack_top]); } }
Object *extract(Binding *binding, char *key) { Entry **owner = find_owner(binding, key); if (owner == NULL) { return NULL; } Entry *entry = *owner; *owner = entry->next; return free_entry(entry); }
static int process_entry_ref(entry_ref_t *entry_ref, process_params_t *params) { char *data = NULL; int dsize = 0; entry_t *entry = NULL; char *xcap_uri; int res; /* DEBUG_LOG("processing entry-ref with ref \'%s\'\n", STR_OK(entry_ref->ref)); */ if (!entry_ref) return RES_OK; if (!entry_ref->ref) return RES_OK; if (add_uri_to_traversed(params, entry_ref->ref) != 0) { /* It is existing yet? */ ERROR_LOG("Duplicate URI in traversed set\n"); return RES_BAD_GATEWAY_ERR; /* 502 Bad GW */ } /* XCAP query for the ref uri */ xcap_uri = relative2absolute_uri(params->xcap_root, entry_ref->ref); res = xcap_query(xcap_uri, params->xcap_params, &data, &dsize); if (res != 0) { ERROR_LOG("XCAP problems for uri \'%s\'\n", xcap_uri ? xcap_uri: "???"); if (data) cds_free(data); if (xcap_uri) cds_free(xcap_uri); return RES_BAD_GATEWAY_ERR; /* 502 Bad GW */ } if (xcap_uri) cds_free(xcap_uri); /* parse document as an entry element */ if (parse_entry_xml(data, dsize, &entry) != 0) { ERROR_LOG("Parsing problems!\n"); if (entry) free_entry(entry); if (data) cds_free(data); return RES_BAD_GATEWAY_ERR; /* 502 Bad GW */ } if (data) cds_free(data); if (!entry) return RES_INTERNAL_ERR; /* ??? */ res = process_entry(entry, params); free_entry(entry); return res; }
void LoaderConstraintTable::merge_loader_constraints( LoaderConstraintEntry** pp1, LoaderConstraintEntry** pp2, klassOop klass) { // make sure *pp1 has higher capacity if ((*pp1)->max_loaders() < (*pp2)->max_loaders()) { LoaderConstraintEntry** tmp = pp2; pp2 = pp1; pp1 = tmp; } LoaderConstraintEntry* p1 = *pp1; LoaderConstraintEntry* p2 = *pp2; ensure_loader_constraint_capacity(p1, p2->num_loaders()); for (int i = 0; i < p2->num_loaders(); i++) { int num = p1->num_loaders(); p1->set_loader(num, p2->loader(i)); p1->set_num_loaders(num + 1); } if (TraceLoaderConstraints) { ResourceMark rm; tty->print_cr("[Merged constraints for name %s, new loader list:", p1->name()->as_C_string() ); for (int i = 0; i < p1->num_loaders(); i++) { tty->print_cr("[ [%d]: %s", i, SystemDictionary::loader_name(p1->loader(i))); } if (p1->klass() == NULL) { tty->print_cr("[... and setting class object]"); } } // p1->klass() will hold NULL if klass, p2->klass(), and old // p1->klass() are all NULL. In addition, all three must have // matching non-NULL values, otherwise either the constraints would // have been violated, or the constraints had been corrupted (and an // assertion would fail). if (p2->klass() != NULL) { assert(p2->klass() == klass, "constraints corrupted"); } if (p1->klass() == NULL) { p1->set_klass(klass); } else { assert(p1->klass() == klass, "constraints corrupted"); } *pp2 = p2->next(); FREE_C_HEAP_ARRAY(oop, p2->loaders()); free_entry(p2); return; }
static void __remove_mapping(struct smq_policy *mq, dm_oblock_t oblock) { struct entry *e; e = h_lookup(&mq->table, oblock); BUG_ON(!e); del(mq, e); free_entry(&mq->cache_alloc, e); }
// FREE AVL static void _free_avl(struct avl_nodo *nodo){ if(nodo == NULL) return; _free_avl(nodo->izq); _free_avl(nodo->der); free_entry(nodo->e); free(nodo->e); free(nodo); }
/** * Iterator over hash map entries. * * @param cls closure * @param key current key * @param value value in the hash map * @return GNUNET_YES if we should continue to * iterate, * GNUNET_NO if not. */ static int cache_clear_iterator (void *cls, uint32_t key, void *value) { struct CacheEntry *entry = value; GNUNET_assert (NULL != entry); GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_multihashmap32_remove (cache, key, value)); free_entry (entry); return GNUNET_YES; }
/* Frees a entry entry = entry to free */ void memory_manager_free(void *memory) { if (!memory) { /* check it's not null */ return; } uint32_t size = sizeof(memory) + sizeof(memory_page); /* get the real size of the page */ if (!(size & ~327684)) { /* if we have a bucket big enough */ free_entry(memory - sizeof(memory_page), size); } else { free(memory); /* else its an os page */ } }
void free_user(user *u) { entry *e, *ne; free(u->name); for (e = u->crontab; e != NULL; e = ne) { ne = e->next; free_entry(e); } free(u); }
int remove_from_hash(h_entry_t* hash, unsigned int hash_size, dc_t* cell, int type) { int hash_entry=0; entry_t *it, *tmp; if(!cell) return 0; if(!hash) return -1; /* find the list where the cell must be */ if(type==DHASH) hash_entry = get_hash_entry(cell->dhash, hash_size); else if(type==CHASH) hash_entry = get_hash_entry(cell->code, hash_size); else return -1; lock_get(&hash[hash_entry].lock); /* first element of the list */ it = hash[hash_entry].e; /* find the cell in the list */ /* a double linked list in the hash is kept alphabetically * or numerical ordered */ tmp = NULL; while(it!=NULL && it->dc != cell) { tmp = it; it = it->n; } if(it) { if(tmp) tmp->n = it->n; else hash[hash_entry].e = it->n; if(it->n) it->n->p = it->p; free_entry(it, (type==DHASH?ERASE_CELL:NOT_ERASE_CELL)); } lock_release(&hash[hash_entry].lock); return 0; }
static int __remove_cblock(struct smq_policy *mq, dm_cblock_t cblock) { struct entry *e = get_entry(&mq->cache_alloc, from_cblock(cblock)); if (!e || !e->allocated) return -ENODATA; del(mq, e); free_entry(&mq->cache_alloc, e); return 0; }
static void free_entry(ReplayMessageTreeEntry *entry) { ReplayMessageTreeEntry *child; while ((child = entry->first_child) != NULL) { entry->first_child = child->next; free_entry(child); } gtk_tree_path_free(entry->tree_path); g_free(entry->name); g_free(entry); }
void pa_scache_free_all(pa_core *c) { pa_scache_entry *e; pa_assert(c); while ((e = pa_idxset_steal_first(c->scache, NULL))) free_entry(e); if (c->scache_auto_unload_event) { c->mainloop->time_free(c->scache_auto_unload_event); c->scache_auto_unload_event = NULL; } }
static void free_enumeration(struct enumeration *enumeration) { struct entry *e, *e_next; free(enumeration->name); free(enumeration->uppercase_name); free_description(enumeration->description); wl_list_for_each_safe(e, e_next, &enumeration->entry_list, link) free_entry(e); free(enumeration); }
int node_put_data_packet_force(struct node *node, struct packet *pkt, cb_fn *callback, void *data) { int ret; struct entry *e; e = create_cb_entry(pkt, callback, data); if (!e) return -1; ret = queue_put_force(e, node->data_q); if (ret < 0) free_entry(e); return ret; }
int node_put_data_packet(struct node *node, struct packet *pkt) { struct entry *e; e = create_entry(pkt); if(e == NULL) { return -1; } if(queue_put(e, node->data_q) < 0){ free_entry(e); return -1; } return 0; }
struct packet *node_get_meta_packet(struct node *node) { struct entry *e; struct packet *pkt; e = queue_get(node->meta_q); if(e == NULL) { return NULL; } pkt = (struct packet *)e->data; free_entry(e); return pkt; }
Binding *free_binding(Binding *binding) { if (binding->reference_count > 1L) { binding->reference_count--; return binding->parent; } Binding *parent = binding->parent; Entry *entry = binding->first; while (entry != NULL) { Entry *next = entry->next; destroy(free_entry(entry)); entry = next; } free_binding(binding->parent); free(binding); return parent; }