void fib_release_info(struct fib_info *fi)
{
spin_lock_bh(&fib_info_lock);
if (fi && --fi->fib_treeref == 0) {
hlist_del(&fi->fib_hash);
if (fi->fib_prefsrc)
hlist_del(&fi->fib_lhash);
change_nexthops(fi) {
if (!nh->nh_dev)
continue;
hlist_del(&nh->nh_hash);
}
endfor_nexthops(fi)
fi->fib_dead = 1;
fib_info_put(fi);
}
static void
__instance_destroy(struct nfulnl_instance *inst)
{
/* first pull it out of the global list */
UDEBUG("removing instance %p (queuenum=%u) from hash\n",
inst, inst->group_num);
hlist_del(&inst->hlist);
/* then flush all pending packets from skb */
spin_lock_bh(&inst->lock);
if (inst->skb) {
/* timer "holds" one reference (we have one more) */
if (del_timer(&inst->timer))
instance_put(inst);
if (inst->qlen)
__nfulnl_send(inst);
if (inst->skb) {
kfree_skb(inst->skb);
inst->skb = NULL;
}
}
spin_unlock_bh(&inst->lock);
/* and finally put the refcount */
instance_put(inst);
}
static int __msm_pmem_table_del(struct hlist_head *ptype,
struct msm_pmem_info *pinfo)
{
int rc = 0;
struct msm_pmem_region *region;
struct hlist_node *node, *n;
switch (pinfo->type) {
case MSM_PMEM_AEC_AWB:
case MSM_PMEM_AF:
hlist_for_each_entry_safe(region, node, n,
ptype, list) {
if (pinfo->type == region->info.type &&
pinfo->vaddr == region->info.vaddr &&
pinfo->fd == region->info.fd) {
hlist_del(node);
#ifdef CONFIG_ANDROID_PMEM
put_pmem_file(region->file);
#else
#endif
kfree(region);
}
}
break;
default:
rc = -EINVAL;
break;
}
return rc;
}
void _req_may_be_done(struct drbd_request *req, struct bio_and_error *m)
{
const unsigned long s = req->rq_state;
struct drbd_conf *mdev = req->mdev;
int rw = req->master_bio ? bio_data_dir(req->master_bio) : WRITE;
if (s & RQ_NET_QUEUED)
return;
if (s & RQ_NET_PENDING)
return;
if (s & RQ_LOCAL_PENDING)
return;
if (req->master_bio) {
int ok = (s & RQ_LOCAL_OK) || (s & RQ_NET_OK);
int error = PTR_ERR(req->private_bio);
if (!hlist_unhashed(&req->collision))
hlist_del(&req->collision);
else
D_ASSERT((s & (RQ_NET_MASK & ~RQ_NET_DONE)) == 0);
if (rw == WRITE)
_about_to_complete_local_write(mdev, req);
_drbd_end_io_acct(mdev, req);
m->error = ok ? 0 : (error ?: -EIO);
m->bio = req->master_bio;
req->master_bio = NULL;
}
//Called when module unloaded using 'rmmod'
void cleanup_module()
{
print_all();
nf_unregister_hook(&nfho); //cleanup – unregister hook
//TODO - cleanup hash table
kfree(ts);
int i;
for(i = 0; i < GLOBAL_MAP_SIZE; i++){
if(global_map[i]){
struct hlist_node* n;
struct hlist_node* old;
hte_t* h;
/*
hlist_for_each(n, global_map[i]){
h = hlist_entry(h, hte_t, node);
hlist_del(n);
//if(h) kfree(h);
//kfree(n);
}
*/
n = global_map[i]->first;
while(n){
h = hlist_entry(n,hte_t, node);
old = n;
n = n->next;
hlist_del(old);
//kfree(old);
kfree(h);
}
kfree(global_map[i]);
}
}
kfree(global_map);
}
static void
_instance_destroy2(struct nfulnl_instance *inst, int lock)
{
/* first pull it out of the global list */
if (lock)
write_lock_bh(&instances_lock);
UDEBUG("removing instance %p (queuenum=%u) from hash\n",
inst, inst->group_num);
hlist_del(&inst->hlist);
if (lock)
write_unlock_bh(&instances_lock);
/* then flush all pending packets from skb */
spin_lock_bh(&inst->lock);
if (inst->skb) {
if (inst->qlen)
__nfulnl_send(inst);
if (inst->skb) {
kfree_skb(inst->skb);
inst->skb = NULL;
}
}
spin_unlock_bh(&inst->lock);
/* and finally put the refcount */
instance_put(inst);
module_put(THIS_MODULE);
}
static void faf_polled_fd_node_free(struct faf_polled_fd *polled_fd,
struct faf_polled_fd_node *polled_fd_node)
{
BUG_ON(polled_fd_node->count);
hlist_del(&polled_fd_node->list);
polled_fd->count--;
kfree(polled_fd_node);
}
static void patch_destroy(struct vport *vport)
{
struct patch_vport *patch_vport = patch_vport_priv(vport);
update_peers(ovs_dp_get_net(vport->dp), patch_vport->name, NULL);
hlist_del(&patch_vport->hash_node);
call_rcu(&patch_vport->rcu, free_port_rcu);
}
void auth_domain_put(struct auth_domain *dom)
{
if (atomic_dec_and_lock(&dom->ref.refcount, &auth_domain_lock)) {
hlist_del(&dom->hash);
dom->flavour->domain_release(dom);
spin_unlock(&auth_domain_lock);
}
}
static inline void free_ll_remote_perm(struct ll_remote_perm *lrp)
{
if (!lrp)
return;
if (!hlist_unhashed(&lrp->lrp_list))
hlist_del(&lrp->lrp_list);
OBD_SLAB_FREE(lrp, ll_remote_perm_cachep, sizeof(*lrp));
}
/**
* batadv_frag_clear_chain - delete entries in the fragment buffer chain
* @head: head of chain with entries.
*
* Free fragments in the passed hlist. Should be called with appropriate lock.
*/
static void batadv_frag_clear_chain(struct hlist_head *head)
{
struct batadv_frag_list_entry *entry;
struct hlist_node *node;
hlist_for_each_entry_safe(entry, node, head, list) {
hlist_del(&entry->list);
kfree_skb(entry->skb);
kfree(entry);
}
void khashmap_del(struct khashmap *hlist, u64 key)
{
struct khashmap_item *item;
item = khashmap_find_item(hlist, key);
if (!item)
return;
hlist_del(&item->hlist);
kmem_cache_free(hlist_cachep, item);
}
void nfc_llcp_free_sdp_tlv_list(struct hlist_head *head)
{
struct nfc_llcp_sdp_tlv *sdp;
struct hlist_node *n;
hlist_for_each_entry_safe(sdp, n, head, node) {
hlist_del(&sdp->node);
nfc_llcp_free_sdp_tlv(sdp);
}
void *slab_alloc(ohc_slab_t *slab)
{
slab_block_t *sblock;
uintptr_t leader;
struct hlist_node *p;
int buckets;
int i;
if(hlist_empty(&slab->block_head)) {
buckets = slab_buckets(slab);
sblock = malloc(sizeof(slab_block_t) + slab->item_size * buckets);
if(sblock == NULL) {
return NULL;
}
sblock->slab = slab;
sblock->frees = buckets;
hlist_add_head(&sblock->block_node, &slab->block_head);
INIT_HLIST_HEAD(&sblock->item_head);
leader = (uintptr_t)sblock + sizeof(slab_block_t);
for(i = 0; i < buckets; i++) {
*((slab_block_t **)leader) = sblock;
p = (struct hlist_node *)(leader + sizeof(slab_block_t *));
hlist_add_head(p, &sblock->item_head);
leader += slab->item_size;
}
} else {
sblock = list_entry(slab->block_head.first, slab_block_t, block_node);
}
p = sblock->item_head.first;
hlist_del(p);
sblock->frees--;
if(sblock->frees == 0) {
/* if no free items, we throw the block away */
hlist_del(&sblock->block_node);
}
return p;
}
void unregister_kprobe(struct kprobe *p)
{
unsigned long flags;
arch_remove_kprobe(p);
spin_lock_irqsave(&kprobe_lock, flags);
*p->addr = p->opcode;
hlist_del(&p->hlist);
flush_icache_range((unsigned long) p->addr,
(unsigned long) p->addr + sizeof(kprobe_opcode_t));
spin_unlock_irqrestore(&kprobe_lock, flags);
}
static void invalidate_pte(struct kvm_vcpu *vcpu, struct hpte_cache *pte)
{
dprintk_mmu("KVM: Flushing SPT: 0x%lx (0x%llx) -> 0x%llx\n",
pte->pte.eaddr, pte->pte.vpage, pte->host_va);
/* Different for 32 and 64 bit */
kvmppc_mmu_invalidate_pte(vcpu, pte);
if (pte->pte.may_write)
kvm_release_pfn_dirty(pte->pfn);
else
kvm_release_pfn_clean(pte->pfn);
hlist_del(&pte->list_pte);
hlist_del(&pte->list_vpte);
hlist_del(&pte->list_vpte_long);
vcpu->arch.hpte_cache_count--;
kmem_cache_free(hpte_cache, pte);
}
/**
* llc_sap_remove_socket - removes a socket from SAP
* @sap: SAP
* @sk: socket
*
* This function removes a connection from the hash tables of a SAP if
* the connection was in this list.
*/
void llc_sap_remove_socket(struct llc_sap *sap, struct sock *sk)
{
struct llc_sock *llc = llc_sk(sk);
spin_lock_bh(&sap->sk_lock);
sk_nulls_del_node_init_rcu(sk);
hlist_del(&llc->dev_hash_node);
sap->sk_count--;
spin_unlock_bh(&sap->sk_lock);
llc_sap_put(sap);
}
/*
* @inmates must have been initialised prior to this call
*/
static void __cell_release(struct dm_bio_prison_cell *cell,
struct bio_list *inmates)
{
hlist_del(&cell->list);
if (inmates) {
if (cell->holder)
bio_list_add(inmates, cell->holder);
bio_list_merge(inmates, &cell->bios);
}
}
/**
* batadv_forw_packet_list_free() - free a list of forward packets
* @head: a list of to be freed forw_packets
*
* This function cancels the scheduling of any packet in the provided list,
* waits for any possibly running packet forwarding thread to finish and
* finally, safely frees this forward packet.
*
* This function might sleep.
*/
static void batadv_forw_packet_list_free(struct hlist_head *head)
{
struct batadv_forw_packet *forw_packet;
struct hlist_node *safe_tmp_node;
hlist_for_each_entry_safe(forw_packet, safe_tmp_node, head,
cleanup_list) {
cancel_delayed_work_sync(&forw_packet->delayed_work);
hlist_del(&forw_packet->cleanup_list);
batadv_forw_packet_free(forw_packet, true);
}
void khashmap_destroy(struct khashmap *hlist)
{
struct khashmap_item *item;
struct hlist_node *node, *p;
int i;
if (unlikely(!hlist))
return;
khashmap_for_each_entry_safe(hlist, i, node, p, item) {
hlist_del(&item->hlist);
kmem_cache_free(hlist_cachep, item);
}
/*
* Delete a file after having released all locks, blocks and shares
*/
static inline void
nlm_delete_file(struct nlm_file *file)
{
nlm_debug_print_file("closing file", file);
if (!hlist_unhashed(&file->f_list)) {
hlist_del(&file->f_list);
nlmsvc_ops->fclose(file->f_file);
kfree(file);
} else {
printk(KERN_WARNING "lockd: attempt to release unknown file!\n");
}
}
static void tcf_hash_destroy(struct tcf_hashinfo *hinfo, struct tc_action *p)
{
spin_lock_bh(&hinfo->lock);
hlist_del(&p->tcfa_head);
spin_unlock_bh(&hinfo->lock);
gen_kill_estimator(&p->tcfa_rate_est);
/*
* gen_estimator est_timer() might access p->tcfa_lock
* or bstats, wait a RCU grace period before freeing p
*/
call_rcu(&p->tcfa_rcu, free_tcf);
}
extern int
hashtable_del_node(struct hlist_node *node)
{
if (NULL == node) {
eag_log_err("hashtable_del_node input error!\n");
return ERR_HASH_PARAM_ERR;
}
// unsigned int hash_value = 0;
hlist_del(node);
return HASH_RETURN_OK;
}
static void remove_from_hash(struct buffer_head *buf)
{
struct buffer_head *node = NULL;
struct hlist_head *head = &HASH(buf->b_dev,buf->b_blocknr);
spin_lock(&hash_lock);
hlist_for_each_entry(node, head, list_free){
if (node->b_dev == buf->b_dev && node->b_blocknr == buf->b_blocknr) {
hlist_del(&node->list_free);
break;
}
}
buffer_count--;
spin_unlock(&hash_lock);
}
static inline void put_entry(struct trunk_entry_incore *entry)
{
int h = hash(entry->raw.oid);
pthread_mutex_lock(&hashtable_lock[h]);
hlist_del(&entry->hash);
pthread_mutex_unlock(&hashtable_lock[h]);
pthread_mutex_lock(&active_list_lock);
list_del(&entry->active_list);
trunk_entry_active_nr--;
pthread_mutex_unlock(&active_list_lock);
free(entry);
}
int nfc_genl_llc_send_sdres(struct nfc_dev *dev, struct hlist_head *sdres_list)
{
struct sk_buff *msg;
struct nlattr *sdp_attr, *uri_attr;
struct nfc_llcp_sdp_tlv *sdres;
struct hlist_node *n;
void *hdr;
int rc = -EMSGSIZE;
int i;
msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
if (!msg)
return -ENOMEM;
hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
NFC_EVENT_LLC_SDRES);
if (!hdr)
goto free_msg;
if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
goto nla_put_failure;
sdp_attr = nla_nest_start(msg, NFC_ATTR_LLC_SDP);
if (sdp_attr == NULL) {
rc = -ENOMEM;
goto nla_put_failure;
}
i = 1;
hlist_for_each_entry_safe(sdres, n, sdres_list, node) {
pr_debug("uri: %s, sap: %d\n", sdres->uri, sdres->sap);
uri_attr = nla_nest_start(msg, i++);
if (uri_attr == NULL) {
rc = -ENOMEM;
goto nla_put_failure;
}
if (nla_put_u8(msg, NFC_SDP_ATTR_SAP, sdres->sap))
goto nla_put_failure;
if (nla_put_string(msg, NFC_SDP_ATTR_URI, sdres->uri))
goto nla_put_failure;
nla_nest_end(msg, uri_attr);
hlist_del(&sdres->node);
nfc_llcp_free_sdp_tlv(sdres);
}
static struct entry *hash_lookup(struct mq_policy *mq, dm_oblock_t oblock)
{
unsigned h = hash_64(from_oblock(oblock), mq->hash_bits);
struct hlist_head *bucket = mq->table + h;
struct entry *e;
hlist_for_each_entry(e, bucket, hlist)
if (e->oblock == oblock) {
hlist_del(&e->hlist);
hlist_add_head(&e->hlist, bucket);
return e;
}
return NULL;
}
/*
* Expand the size of the hash table to @size.
* @ht: the hash table to expand
* @size: the size we expand to
*/
static int uproc_htable_expand(uproc_htable_t *ht, int size){
int new_len, new_idx, new_load_limit, i;
struct hlist_head *new_buckets, *head;
struct hlist_node *p, *q;
unsigned h;
new_load_limit = ht->load_limit;
new_len = ht->len;
new_idx = ht->p_index;
while(new_load_limit < size && new_idx < uproc_htable_nprimes){
new_len = uproc_htable_primes[++new_idx];
new_load_limit = ht->load_factor * new_len;
}
if((new_buckets = malloc(new_len * sizeof(struct hlist_head))) == NULL){
fprintf(stderr, "failed to malloc: %s", strerror(errno));
return -ENOMEM;
}
for(i = 0; i < new_len; ++i){
INIT_HLIST_HEAD(&new_buckets[i]);
}
/*
* Rehash and move all event to new_buckets.
*/
for(i = 0; i < ht->len; ++i){
head = &(ht->buckets[i]);
if(!hlist_empty(head)){
p = head->first;
while(p){
q = p->next;
hlist_del(p);
h = ht->hf(p) % new_len;
hlist_add_head(&new_buckets[h], p);
p = q;
}
}
}
free(ht->buckets);
ht->p_index = new_idx;
ht->buckets = new_buckets;
ht->len = new_len;
ht->load_limit = new_load_limit;
return 0;
}
void tcf_hash_destroy(struct tc_action *a)
{
struct tcf_common *p = a->priv;
struct tcf_hashinfo *hinfo = a->ops->hinfo;
spin_lock_bh(&hinfo->lock);
hlist_del(&p->tcfc_head);
spin_unlock_bh(&hinfo->lock);
gen_kill_estimator(&p->tcfc_bstats,
&p->tcfc_rate_est);
/*
* gen_estimator est_timer() might access p->tcfc_lock
* or bstats, wait a RCU grace period before freeing p
*/
kfree_rcu(p, tcfc_rcu);
}
static void
__instance_destroy(struct nfulnl_instance *inst)
{
/* first pull it out of the global list */
hlist_del(&inst->hlist);
/* then flush all pending packets from skb */
spin_lock_bh(&inst->lock);
if (inst->skb)
__nfulnl_flush(inst);
spin_unlock_bh(&inst->lock);
/* and finally put the refcount */
instance_put(inst);
}
