/** * An (internal, private) method -- * Deallocates a frame or page (internal procedure) * MUST BE CALLED with 'frame_lock' held. */ void vm_frame_do_free (void *kpage, bool free_page) { ASSERT (lock_held_by_current_thread(&frame_lock) == true); ASSERT (is_kernel_vaddr(kpage)); ASSERT (pg_ofs (kpage) == 0); // should be aligned // hash lookup : a temporary entry struct frame_table_entry f_tmp; f_tmp.kpage = kpage; struct hash_elem *h = hash_find (&frame_map, &(f_tmp.helem)); if (h == NULL) { PANIC ("The page to be freed is not stored in the table"); } struct frame_table_entry *f; f = hash_entry(h, struct frame_table_entry, helem); hash_delete (&frame_map, &f->helem); list_remove (&f->lelem); // Free resources if(free_page) palloc_free_page(kpage); free(f); }
void fs_inode_pcache_invalidate(struct inode *node, size_t offset, size_t length) { if(!(node->flags & INODE_PCACHE)) return; mutex_acquire(&node->mappings_lock); offset = offset & PAGE_MASK; int page_number = offset / PAGE_SIZE; int npages = ((length-1) / PAGE_SIZE) + 1; for(int i = page_number; i < (page_number + npages); i++) { struct physical_page *entry; if((entry = hash_lookup(&node->physicals, &i, sizeof(i))) != NULL) { mutex_acquire(&entry->lock); if(entry->count == 0) { if(entry->page) { mm_physical_decrement_count(entry->page); } entry->page = 0; hash_delete(&node->physicals, &i, sizeof(i)); mutex_destroy(&entry->lock); kfree(entry); atomic_fetch_sub(&node->mapped_entries_count, 1); } else { mutex_release(&entry->lock); } } } mutex_release(&node->mappings_lock); }
static void sbus_signal_name_owner_changed(struct sbus_incoming_signal *a_signal, void *handler_data) { hash_table_t *table = a_signal->conn->clients; hash_key_t *keys; unsigned long count; unsigned long i; int hret; DEBUG(SSSDBG_TRACE_FUNC, "Clearing UIDs cache\n"); hret = hash_keys(table, &count, &keys); if (hret != HASH_SUCCESS) { DEBUG(SSSDBG_OP_FAILURE, "Unable to get hash keys\n"); return; } for (i = 0; i < count; i++) { hret = hash_delete(table, &keys[i]); if (hret != HASH_SUCCESS) { DEBUG(SSSDBG_MINOR_FAILURE, "Could not delete key from hash\n"); return; } } return; }
void js_vm_object_delete_property (JSVirtualMachine *vm, JSObject *obj, JSSymbol prop) { unsigned int ui; /* Check if we already know this property. */ for (ui = 0; ui < obj->num_props; ui++) if (obj->props[ui].name == prop) { /* Found, remove it from our list of properties. */ obj->props[ui].name = JS_SYMBOL_NULL; obj->props[ui].value.type = JS_UNDEFINED; /* Remove its name from the hash (if present). */ if (obj->hash) { const char *name = js_vm_symname (vm, prop); hash_delete (vm, obj, name, strlen (name)); } /* All done here. */ return; } }
static void bce_delete(struct bcentry *bce, int flush) { pthread_rwlock_wrlock(&bce->lock); if (bce->type != BCE_DAD) { del_task(&bce->tqe); if (bce->type != BCE_NONCE_BLOCK) xfrm_del_bce(&bce->our_addr, &bce->peer_addr); } if (bce->cleanup) bce->cleanup(bce); if (!flush && (bce->type == BCE_CACHED || bce->type == BCE_CACHE_DYING)) { struct timespec minlft; if (!rr_cn_nonce_lft(bce->nonce_hoa, &minlft)) { bce->type = BCE_NONCE_BLOCK; add_task_abs(&minlft, &bce->tqe, _expire); pthread_rwlock_unlock(&bce->lock); return; } } bcache_count--; hash_delete(&bc_hash, &bce->our_addr, &bce->peer_addr); pthread_rwlock_unlock(&bce->lock); bcache_free(bce); }
int main() { int k = 0; int array[] = {4371, 1323, 6173, 4199, 4344, 9679, 1989}; hash_table_ptr tbl = hash_init_table(SIZE, hashfunc, cmp_int); for (; k < 7; k++) { hash_insert(tbl, array[k]); } position p = hash_find(tbl, 6173); position q = hash_find(tbl, 1323); assert(p != -1); assert(p != q); assert(tbl->cells[p].element == 6173); hash_delete(tbl, 6173); p = hash_find(tbl, 6173); assert(p == -1); for (k = 0; k < SIZE; k++) { if (tbl->cells[k].info == legitimate) { printf("%d ", tbl->cells[k].element); } } puts("\n"); hash_destroy_table(&tbl); assert(tbl == NULL); return 0; }
int update_server_record_in_cache(FOREIGN_SERVER *existing, FOREIGN_SERVER *altered) { int error= 0; DBUG_ENTER("update_server_record_in_cache"); /* update the members that haven't been change in the altered server struct with the values of the existing server struct */ merge_server_struct(existing, altered); /* delete the existing server struct from the server cache */ VOID(hash_delete(&servers_cache, (uchar*)existing)); /* Insert the altered server struct into the server cache */ if (my_hash_insert(&servers_cache, (uchar*)altered)) { DBUG_PRINT("info", ("had a problem inserting server %s at %lx", altered->server_name, (long unsigned int) altered)); error= ER_OUT_OF_RESOURCES; } DBUG_RETURN(error); }
errno_t autofs_orphan_maps(struct autofs_ctx *actx) { int hret; unsigned long mcount; unsigned long i; hash_key_t *maps; if (!actx || !actx->maps) { return EINVAL; } hret = hash_keys(actx->maps, &mcount, &maps); if (hret != HASH_SUCCESS) { return EIO; } for (i = 0; i < mcount; i++) { hret = hash_delete(actx->maps, &maps[i]); if (hret != HASH_SUCCESS) { DEBUG(SSSDBG_MINOR_FAILURE, "Could not delete key from hash\n"); continue; } } return EOK; }
/* it called when the PPPoE session was closed */ void pppoed_pppoe_session_close_notify(pppoed *_this, pppoe_session *session) { slist_add(&_this->session_free_list, (void *)(intptr_t)session->session_id); if (_this->acookie_hash != NULL) hash_delete(_this->acookie_hash, (void *)(intptr_t)session->acookie, 0); if (_this->session_hash != NULL) hash_delete(_this->session_hash, (void *)(intptr_t)session->session_id, 0); pppoe_session_fini(session); free(session); }
static void test_hash_delete_1() { char token[64]; struct _hash * hash = hash_create( fnv32, str_cmp, sizeof(token), sizeof(int), 100); int i; for (i=0; i < 100; i++) { sprintf(token, "%d", i); hash_add(hash, token, &i); } assert ( hash->n_items == 100 ); for (i=0; i < 100; i++) { sprintf(token, "%d", i); hash_delete(hash, token, &i); } assert ( hash->n_items == 0 ); for (i=0; i < 100; i++) { sprintf(token, "%d", i); assert ( hash_get(hash, token, &i) == NULL); } hash_remove(hash); }
void autofs_release_fh(autofs_fh_t *fh) { if (fh) { hash_delete(fh->fd); /* * if a mount succeeded, the kernel fd was closed on * the amd side, so it might have been reused. * we set it to -1 after closing it, to avoid the problem. */ if (fh->kernelfd >= 0) close(fh->kernelfd); if (fh->ioctlfd >= 0) { /* * Tell the kernel we're catatonic */ ioctl(fh->ioctlfd, AUTOFS_IOC_CATATONIC, 0); close(fh->ioctlfd); } if (fh->fd >= 0) close(fh->fd); XFREE(fh); } }
int main(int argc, char* argv[]) { HashTable *ht; char *val; ht = hash_init_table(); hash_put(ht, "apple", "red"); hash_put(ht, "lemon", "yellow"); hash_put(ht, "orange", "orange"); print_table(ht); hash_put(ht, "orange", "green"); print_table(ht); hash_delete(ht, "orange"); print_table(ht); val = hash_get(ht, "apple"); val = hash_get(ht, "lemon"); val = hash_get(ht, "orange"); hash_uninit_table(ht); return 0; }
/* resize the hash, returns the pointer to the new hash or NULL on * error. removes the old hash on success. */ struct hashtable_t *hash_resize(struct hashtable_t *hash, int size) { struct hashtable_t *new_hash; struct element_t *bucket; int i; /* initialize a new hash with the new size */ new_hash = hash_new(size, hash->compare, hash->choose); if (new_hash == NULL) return NULL; /* copy the elements */ for (i = 0; i < hash->size; i++) { bucket = hash->table[i]; while (bucket != NULL) { hash_add(new_hash, bucket->data); bucket = bucket->next; } } /* remove hash and eventual overflow buckets but not the content * itself. */ hash_delete(hash, NULL); return new_hash; }
void history_rotate() { hash_node_type* n = NULL; history_pos = (history_pos + 1) % HISTORY_LENGTH; hash_next_item(history, &n); while(n != NULL) { hash_node_type* next = n; history_type* d = (history_type*)n->rec; hash_next_item(history, &next); if(d->last_write == history_pos) { addr_pair key = *(addr_pair*)(n->key); hash_delete(history, &key); free(d); } else { d->recv[history_pos] = 0; d->sent[history_pos] = 0; } n = next; } history_totals.sent[history_pos] = 0; history_totals.recv[history_pos] = 0; if(history_len < HISTORY_LENGTH) { history_len++; } }
int run_delete_event (const char *cmd, size_t argc, char *argv[]) { if (argc != 1) { fprintf (stderr, _("use 'delete-event <name>' to delete an event handler\n")); return -1; } const struct entry key = { .name = argv[0] }; struct entry *entry, *p; entry = hash_delete (event_handlers, &key); if (!entry) { fprintf (stderr, _("delete-event: %s: no such event handler\n"), argv[0]); return -1; } /* Delete them from the handle. */ p = entry; while (p) { guestfs_delete_event_callback (g, p->eh); p = p->next; } /* Free the structures. */ entry_free (entry); return 0; }
/* * dead_client() * Someone has gone away. Free their info. */ static void dead_client(struct msg *m, struct file *f) { (void)hash_delete(filehash, m->m_sender); tmpfs_close(f); free(f); }
void js_vm_object_delete_array (JSVirtualMachine *vm, JSObject *obj, JSNode *sel) { if (sel->type == JS_INTEGER) { if (0 <= sel->u.vinteger && sel->u.vinteger < obj->num_props) { JSSymbol sym; sym = obj->props[sel->u.vinteger].name; obj->props[sel->u.vinteger].name = JS_SYMBOL_NULL; obj->props[sel->u.vinteger].value.type = JS_UNDEFINED; /* Remove its name from the hash (if present and it is not NULL). */ if (sym != JS_SYMBOL_NULL && obj->hash) { const char *name = js_vm_symname (vm, sym); hash_delete (vm, obj, name, strlen (name)); } } } else if (sel->type == JS_STRING) { int pos; if (obj->hash == NULL) hash_create (vm, obj); pos = hash_lookup (obj, (char *) sel->u.vstring->data, sel->u.vstring->len); if (pos >= 0) { /* Found it. */ obj->props[pos].name = JS_SYMBOL_NULL; obj->props[pos].value.type = JS_UNDEFINED; /* And, delete its name from the hash. */ hash_delete (vm, obj, (char *) sel->u.vstring->data, sel->u.vstring->len); } } else { sprintf (vm->error, "delete_array: illegal array index"); js_vm_error (vm); } }
void hna_global_free(struct bat_priv *bat_priv) { if (!bat_priv->hna_global_hash) return; hash_delete(bat_priv->hna_global_hash, hna_global_del, NULL); bat_priv->hna_global_hash = NULL; }
int main() { struct hash * h = hash_new(); test(h); search(h); hash_delete(h); return 0; }
void pptpd_release_call(pptpd *_this, pptp_call *call) { if (call->id != 0) slist_add(&_this->call_free_list, (void *)call->id); hash_delete(_this->call_id_map, CALL_MAP_KEY(call), 0); call->id = 0; }
void hna_global_free(void) { if (!hna_global_hash) return; hash_delete(hna_global_hash, hna_global_del); hna_global_hash = NULL; }
END_TEST START_TEST(test_hash_delete_2) { hash_t hash = {0}; hash_init(&hash, 10); ck_assert_int_eq(hash_delete(&hash, "foo"), 0); }
int main(int argc, const char* argv[]) { struct simple_hash ht; init_hash(&ht,128); for (;;) { char buf[256]; if (fgets(buf, 256, stdin) == NULL) break; char *command = strtok(buf, whitespace); unsigned int key; unsigned int value; if (strcmp(command, "insert") == 0) { sscanf(strtok(NULL, whitespace), "%u", &key); sscanf(strtok(NULL, whitespace), "%u", &value); hash_insert(&ht,key,value); } else if (strcmp(command, "lookup") == 0) { sscanf(strtok(NULL, whitespace), "%u", &key); size_t value; int result; result=hash_lookup(&ht,key, &value); if (result==0) printf("%u\n", (unsigned int) value); else printf("None\n"); } else if (strcmp(command, "increment") == 0) { sscanf(strtok(NULL, whitespace), "%u", &key); hash_cell_insert(&ht,key)->value++; } else if (strcmp(command, "delete") == 0) { sscanf(strtok(NULL, whitespace), "%u", &key); hash_delete(&ht,key); } else if (strcmp(command, "clear") == 0) { clear_hash(&ht); } else if (strcmp(command, "compact") == 0) { compact_hash(&ht); } fflush(stdout); } // Dump entire table printf("{\n"); if(ht.m_zeroUsed) printf(" %u: %u,\n", ht.m_zeroCell.key, ht.m_zeroCell.value); for(size_t i=0;i<ht.m_arraySize;i++) if(ht.m_cells[i].key) printf(" %u: %u,\n", ht.m_cells[i].key, ht.m_cells[i].value); printf("}\n"); end_hash(&ht); return 0; }
void viewTasksMemory(void){ pTable *tasksmemory; tasksmemory = hash_new((void *)free_task); getTasksMemory(tasksmemory); simpleViewTasks(tasksmemory); hash_delete(tasksmemory); }
void hna_local_free(void) { if (!hna_local_hash) return; cancel_delayed_work_sync(&hna_local_purge_wq); hash_delete(hna_local_hash, _hna_local_del); hna_local_hash = NULL; }
/* Remove directory entry for the given CANAME */ void remove_directory (const char *caname) { struct directory *dir = make_directory (caname, xstrdup (caname)); struct directory *ret = hash_delete (directory_table, dir); if (ret) free_directory (ret); free_directory (dir); }
void hna_local_free(struct bat_priv *bat_priv) { if (!bat_priv->hna_local_hash) return; cancel_delayed_work_sync(&bat_priv->hna_work); hash_delete(bat_priv->hna_local_hash, _hna_local_del, bat_priv); bat_priv->hna_local_hash = NULL; }
static void kill_page(HyperDocPage * page) { page->scroll_off = 0; if (page->type == SpadGen) { hash_delete(gWindow->fPageHashTable, page->name); killAxiomPage(page); free_page(page); } }
void frame_remove_by_upage (void *upage) { struct frame *f = frame_find_upage (upage); if (f != NULL) { hash_delete (&frame_table, &f->hash_elem); free (f); } }
inline bool remove(char *name, uint namelen) { sp_head *sp= lookup(name, namelen); if (sp) { hash_delete(&m_hashtable, (uchar *)sp); return TRUE; } return FALSE; }