static void pep_sock_unhash(struct sock *sk) { struct pep_sock *pn = pep_sk(sk); struct sock *skparent = NULL; lock_sock(sk); if (pn->listener != NULL) { skparent = pn->listener; pn->listener = NULL; release_sock(sk); pn = pep_sk(skparent); lock_sock(skparent); sk_del_node_init(sk); sk = skparent; } /* Unhash a listening sock only when it is closed * and all of its active connected pipes are closed. */ if (hlist_empty(&pn->hlist)) pn_sock_unhash(&pn->pn_sk.sk); release_sock(sk); if (skparent) sock_put(skparent); }
void raw_unhash_sk(struct sock *sk) { struct raw_hashinfo *h = sk->sk_prot->h.raw_hash; write_lock_bh(&h->lock); if (sk_del_node_init(sk)) sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1); write_unlock_bh(&h->lock); }
static void netlink_remove(struct sock *sk) { netlink_table_grab(); nl_table[sk->sk_protocol].hash.entries--; sk_del_node_init(sk); if (nlk_sk(sk)->groups) __sk_del_bind_node(sk); netlink_table_ungrab(); }
static int packet_release(struct socket *sock) { struct sock *sk = sock->sk; struct packet_sock *po; if (!sk) return 0; po = pkt_sk(sk); write_lock_bh(&packet_sklist_lock); sk_del_node_init(sk); write_unlock_bh(&packet_sklist_lock); /* * Unhook packet receive handler. */ if (po->running) { /* * Remove the protocol hook */ dev_remove_pack(&po->prot_hook); po->running = 0; po->num = 0; __sock_put(sk); } #ifdef CONFIG_PACKET_MULTICAST packet_flush_mclist(sk); #endif #ifdef CONFIG_PACKET_MMAP if (po->pg_vec) { struct tpacket_req req; memset(&req, 0, sizeof(req)); packet_set_ring(sk, &req, 1); } #endif /* * Now the socket is dead. No more input will appear. */ sock_orphan(sk); sock->sk = NULL; /* Purge queues */ skb_queue_purge(&sk->sk_receive_queue); sock_put(sk); return 0; }
void atm_dev_release_vccs(struct atm_dev *dev) { int i; write_lock_irq(&vcc_sklist_lock); for (i = 0; i < VCC_HTABLE_SIZE; i++) { struct hlist_head *head = &vcc_hash[i]; struct hlist_node *node, *tmp; struct sock *s; struct atm_vcc *vcc; sk_for_each_safe(s, node, tmp, head) { vcc = atm_sk(s); if (vcc->dev == dev) { vcc_release_async(vcc, -EPIPE); sk_del_node_init(s); } } }
static struct sock *pep_sock_accept(struct sock *sk, int flags, int *errp) { struct pep_sock *pn = pep_sk(sk); struct sock *newsk = NULL; struct sk_buff *oskb; int err; lock_sock(sk); err = pep_wait_connreq(sk, flags & O_NONBLOCK); if (err) goto out; newsk = __sk_head(&pn->ackq); oskb = skb_dequeue(&newsk->sk_receive_queue); err = pep_accept_conn(newsk, oskb); if (err) { skb_queue_head(&newsk->sk_receive_queue, oskb); newsk = NULL; goto out; } kfree_skb(oskb); sock_hold(sk); pep_sk(newsk)->listener = sk; sock_hold(newsk); sk_del_node_init(newsk); sk_acceptq_removed(sk); sk_add_node(newsk, &pn->hlist); __sock_put(newsk); out: release_sock(sk); *errp = err; return newsk; }
/* associated socket ceases to exist */ static void pep_sock_close(struct sock *sk, long timeout) { struct pep_sock *pn = pep_sk(sk); int ifindex = 0; sk_common_release(sk); lock_sock(sk); if (sk->sk_state == TCP_LISTEN) { /* Destroy the listen queue */ struct sock *sknode; struct hlist_node *p, *n; sk_for_each_safe(sknode, p, n, &pn->ackq) sk_del_node_init(sknode); sk->sk_state = TCP_CLOSE; } ifindex = pn->ifindex; pn->ifindex = 0; release_sock(sk); if (ifindex) gprs_detach(sk); }
static void vcc_remove_socket(struct sock *sk) { write_lock_irq(&vcc_sklist_lock); sk_del_node_init(sk); write_unlock_irq(&vcc_sklist_lock); }
static void nr_remove_socket(struct sock *sk) { spin_lock_bh(&nr_list_lock); sk_del_node_init(sk); spin_unlock_bh(&nr_list_lock); }
static void mISDN_sock_unlink(struct mISDN_sock_list *l, struct sock *sk) { write_lock_bh(&l->lock); sk_del_node_init(sk); write_unlock_bh(&l->lock); }