X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=net%2Fnetlink%2Faf_netlink.c;h=118c172c48ca9069ae6120f158fa84cb39f39f86;hb=6a77f38946aaee1cd85eeec6cf4229b204c15071;hp=9a77db793577fcd754091b7b0c7a1caecad07795;hpb=5273a3df6485dc2ad6aa7ddd441b9a21970f003b;p=linux-2.6.git diff --git a/net/netlink/af_netlink.c b/net/netlink/af_netlink.c index 9a77db793..118c172c4 100644 --- a/net/netlink/af_netlink.c +++ b/net/netlink/af_netlink.c @@ -44,6 +44,15 @@ #include #include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include #include @@ -56,9 +65,9 @@ struct netlink_opt { u32 pid; - unsigned groups; + unsigned int groups; u32 dst_pid; - unsigned dst_groups; + unsigned int dst_groups; unsigned long state; int (*handler)(int unit, struct sk_buff *skb); wait_queue_head_t wait; @@ -69,24 +78,42 @@ struct netlink_opt #define nlk_sk(__sk) ((struct netlink_opt *)(__sk)->sk_protinfo) -static struct hlist_head nl_table[MAX_LINKS]; -static DECLARE_WAIT_QUEUE_HEAD(nl_table_wait); -static unsigned nl_nonroot[MAX_LINKS]; +struct nl_pid_hash { + struct hlist_head *table; + unsigned long rehash_time; -#ifdef NL_EMULATE_DEV -static struct socket *netlink_kernel[MAX_LINKS]; -#endif + unsigned int mask; + unsigned int shift; + + unsigned int entries; + unsigned int max_shift; + + u32 rnd; +}; + +struct netlink_table { + struct nl_pid_hash hash; + struct hlist_head mc_list; + unsigned int nl_nonroot; +}; + +static struct netlink_table *nl_table; + +static DECLARE_WAIT_QUEUE_HEAD(nl_table_wait); static int netlink_dump(struct sock *sk); static void netlink_destroy_callback(struct netlink_callback *cb); -atomic_t netlink_sock_nr; - -static rwlock_t nl_table_lock = RW_LOCK_UNLOCKED; +static DEFINE_RWLOCK(nl_table_lock); static atomic_t nl_table_users = ATOMIC_INIT(0); static struct notifier_block *netlink_chain; +static struct hlist_head *nl_pid_hashfn(struct nl_pid_hash *hash, u32 pid) +{ + return &hash->table[jhash_1word(pid, hash->rnd) & hash->mask]; +} + static void netlink_sock_destruct(struct sock *sk) { skb_queue_purge(&sk->sk_receive_queue); @@ -100,11 +127,6 @@ static void netlink_sock_destruct(struct sock *sk) BUG_TRAP(!nlk_sk(sk)->cb); kfree(nlk_sk(sk)); - - atomic_dec(&netlink_sock_nr); -#ifdef NETLINK_REFCNT_DEBUG - printk(KERN_DEBUG "NETLINK %p released, %d are still alive\n", sk, atomic_read(&netlink_sock_nr)); -#endif } /* This lock without WQ_FLAG_EXCLUSIVE is good on UP and it is _very_ bad on SMP. @@ -160,11 +182,14 @@ netlink_unlock_table(void) static __inline__ struct sock *netlink_lookup(int protocol, u32 pid) { + struct nl_pid_hash *hash = &nl_table[protocol].hash; + struct hlist_head *head; struct sock *sk; struct hlist_node *node; read_lock(&nl_table_lock); - sk_for_each(sk, node, &nl_table[protocol]) { + head = nl_pid_hashfn(hash, pid); + sk_for_each(sk, node, head) { if (nlk_sk(sk)->pid == pid) { sock_hold(sk); goto found; @@ -176,27 +201,118 @@ found: return sk; } -extern struct proto_ops netlink_ops; +static inline struct hlist_head *nl_pid_hash_alloc(size_t size) +{ + if (size <= PAGE_SIZE) + return kmalloc(size, GFP_ATOMIC); + else + return (struct hlist_head *) + __get_free_pages(GFP_ATOMIC, get_order(size)); +} + +static inline void nl_pid_hash_free(struct hlist_head *table, size_t size) +{ + if (size <= PAGE_SIZE) + kfree(table); + else + free_pages((unsigned long)table, get_order(size)); +} + +static int nl_pid_hash_rehash(struct nl_pid_hash *hash, int grow) +{ + unsigned int omask, mask, shift; + size_t osize, size; + struct hlist_head *otable, *table; + int i; + + omask = mask = hash->mask; + osize = size = (mask + 1) * sizeof(*table); + shift = hash->shift; + + if (grow) { + if (++shift > hash->max_shift) + return 0; + mask = mask * 2 + 1; + size *= 2; + } + + table = nl_pid_hash_alloc(size); + if (!table) + return 0; + + memset(table, 0, size); + otable = hash->table; + hash->table = table; + hash->mask = mask; + hash->shift = shift; + get_random_bytes(&hash->rnd, sizeof(hash->rnd)); + + for (i = 0; i <= omask; i++) { + struct sock *sk; + struct hlist_node *node, *tmp; + + sk_for_each_safe(sk, node, tmp, &otable[i]) + __sk_add_node(sk, nl_pid_hashfn(hash, nlk_sk(sk)->pid)); + } + + nl_pid_hash_free(otable, osize); + hash->rehash_time = jiffies + 10 * 60 * HZ; + return 1; +} + +static inline int nl_pid_hash_dilute(struct nl_pid_hash *hash, int len) +{ + int avg = hash->entries >> hash->shift; + + if (unlikely(avg > 1) && nl_pid_hash_rehash(hash, 1)) + return 1; + + if (unlikely(len > avg) && time_after(jiffies, hash->rehash_time)) { + nl_pid_hash_rehash(hash, 0); + return 1; + } + + return 0; +} + +static struct proto_ops netlink_ops; static int netlink_insert(struct sock *sk, u32 pid) { + struct nl_pid_hash *hash = &nl_table[sk->sk_protocol].hash; + struct hlist_head *head; int err = -EADDRINUSE; struct sock *osk; struct hlist_node *node; + int len; netlink_table_grab(); - sk_for_each(osk, node, &nl_table[sk->sk_protocol]) { + head = nl_pid_hashfn(hash, pid); + len = 0; + sk_for_each(osk, node, head) { if (nlk_sk(osk)->pid == pid) break; + len++; } - if (!node) { - err = -EBUSY; - if (nlk_sk(sk)->pid == 0) { - nlk_sk(sk)->pid = pid; - sk_add_node(sk, &nl_table[sk->sk_protocol]); - err = 0; - } - } + if (node) + goto err; + + err = -EBUSY; + if (nlk_sk(sk)->pid) + goto err; + + err = -ENOMEM; + if (BITS_PER_LONG > 32 && unlikely(hash->entries >= UINT_MAX)) + goto err; + + if (len && nl_pid_hash_dilute(hash, len)) + head = nl_pid_hashfn(hash, pid); + hash->entries++; + nlk_sk(sk)->pid = pid; + sk_add_node(sk, head); + err = 0; + +err: netlink_table_ungrab(); return err; } @@ -204,7 +320,10 @@ static int netlink_insert(struct sock *sk, u32 pid) 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(); } @@ -240,7 +359,6 @@ static int netlink_create(struct socket *sock, int protocol) spin_lock_init(&nlk->cb_lock); init_waitqueue_head(&nlk->wait); sk->sk_destruct = netlink_sock_destruct; - atomic_inc(&netlink_sock_nr); sk->sk_protocol = protocol; return 0; @@ -290,19 +408,24 @@ static int netlink_release(struct socket *sock) static int netlink_autobind(struct socket *sock) { struct sock *sk = sock->sk; + struct nl_pid_hash *hash = &nl_table[sk->sk_protocol].hash; + struct hlist_head *head; struct sock *osk; struct hlist_node *node; s32 pid = current->pid; int err; + static s32 rover = -4097; retry: + cond_resched(); netlink_table_grab(); - sk_for_each(osk, node, &nl_table[sk->sk_protocol]) { + head = nl_pid_hashfn(hash, pid); + sk_for_each(osk, node, head) { if (nlk_sk(osk)->pid == pid) { /* Bind collision, search negative pid values. */ - if (pid > 0) - pid = -4096; - pid--; + pid = rover--; + if (rover > -4097) + rover = -4097; netlink_table_ungrab(); goto retry; } @@ -316,9 +439,9 @@ retry: return 0; } -static inline int netlink_capable(struct socket *sock, unsigned flag) +static inline int netlink_capable(struct socket *sock, unsigned int flag) { - return (nl_nonroot[sock->sk->sk_protocol] & flag) || + return (nl_table[sock->sk->sk_protocol].nl_nonroot & flag) || capable(CAP_NET_ADMIN); } @@ -339,21 +462,26 @@ static int netlink_bind(struct socket *sock, struct sockaddr *addr, int addr_len if (nlk->pid) { if (nladdr->nl_pid != nlk->pid) return -EINVAL; - nlk->groups = nladdr->nl_groups; - return 0; + } else { + err = nladdr->nl_pid ? + netlink_insert(sk, nladdr->nl_pid) : + netlink_autobind(sock); + if (err) + return err; } - if (nladdr->nl_pid == 0) { - err = netlink_autobind(sock); - if (err == 0) - nlk->groups = nladdr->nl_groups; - return err; - } + if (!nladdr->nl_groups && !nlk->groups) + return 0; - err = netlink_insert(sk, nladdr->nl_pid); - if (err == 0) - nlk->groups = nladdr->nl_groups; - return err; + netlink_table_grab(); + if (nlk->groups && !nladdr->nl_groups) + __sk_del_bind_node(sk); + else if (!nlk->groups && nladdr->nl_groups) + sk_add_bind_node(sk, &nl_table[sk->sk_protocol].mc_list); + nlk->groups = nladdr->nl_groups; + netlink_table_ungrab(); + + return 0; } static int netlink_connect(struct socket *sock, struct sockaddr *addr, @@ -365,6 +493,7 @@ static int netlink_connect(struct socket *sock, struct sockaddr *addr, struct sockaddr_nl *nladdr=(struct sockaddr_nl*)addr; if (addr->sa_family == AF_UNSPEC) { + sk->sk_state = NETLINK_UNCONNECTED; nlk->dst_pid = 0; nlk->dst_groups = 0; return 0; @@ -380,11 +509,12 @@ static int netlink_connect(struct socket *sock, struct sockaddr *addr, err = netlink_autobind(sock); if (err == 0) { + sk->sk_state = NETLINK_CONNECTED; nlk->dst_pid = nladdr->nl_pid; nlk->dst_groups = nladdr->nl_groups; } - return 0; + return err; } static int netlink_getname(struct socket *sock, struct sockaddr *addr, int *addr_len, int peer) @@ -415,7 +545,7 @@ static void netlink_overrun(struct sock *sk) } } -struct sock *netlink_getsockbypid(struct sock *ssk, u32 pid) +static struct sock *netlink_getsockbypid(struct sock *ssk, u32 pid) { int protocol = ssk->sk_protocol; struct sock *sock; @@ -427,7 +557,9 @@ struct sock *netlink_getsockbypid(struct sock *ssk, u32 pid) /* Don't bother queuing skb if kernel socket has no input function */ nlk = nlk_sk(sock); - if (nlk->pid == 0 && !nlk->data_ready) { + if ((nlk->pid == 0 && !nlk->data_ready) || + (sock->sk_state == NETLINK_CONNECTED && + nlk->dst_pid != nlk_sk(ssk)->pid)) { sock_put(sock); return ERR_PTR(-ECONNREFUSED); } @@ -500,7 +632,6 @@ int netlink_attachskb(struct sock *sk, struct sk_buff *skb, int nonblock, long t } return 1; } - skb_orphan(skb); skb_set_owner_r(skb, sk); return 0; } @@ -532,18 +663,44 @@ void netlink_detachskb(struct sock *sk, struct sk_buff *skb) sock_put(sk); } +static inline struct sk_buff *netlink_trim(struct sk_buff *skb, int allocation) +{ + int delta; + + skb_orphan(skb); + + delta = skb->end - skb->tail; + if (delta * 2 < skb->truesize) + return skb; + + if (skb_shared(skb)) { + struct sk_buff *nskb = skb_clone(skb, allocation); + if (!nskb) + return skb; + kfree_skb(skb); + skb = nskb; + } + + if (!pskb_expand_head(skb, 0, -delta, allocation)) + skb->truesize -= delta; + + return skb; +} + int netlink_unicast(struct sock *ssk, struct sk_buff *skb, u32 pid, int nonblock) { struct sock *sk; int err; long timeo; + skb = netlink_trim(skb, gfp_any()); + timeo = sock_sndtimeo(ssk, nonblock); retry: sk = netlink_getsockbypid(ssk, pid); if (IS_ERR(sk)) { kfree_skb(skb); - return PTR_ERR(skb); + return PTR_ERR(sk); } err = netlink_attachskb(sk, skb, nonblock, timeo); if (err == 1) @@ -559,102 +716,156 @@ static __inline__ int netlink_broadcast_deliver(struct sock *sk, struct sk_buff struct netlink_opt *nlk = nlk_sk(sk); #ifdef NL_EMULATE_DEV if (nlk->handler) { - skb_orphan(skb); nlk->handler(sk->sk_protocol, skb); return 0; } else #endif if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf && !test_bit(0, &nlk->state)) { - skb_orphan(skb); skb_set_owner_r(skb, sk); skb_queue_tail(&sk->sk_receive_queue, skb); sk->sk_data_ready(sk, skb->len); - return 0; + return atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf; } return -1; } +struct netlink_broadcast_data { + struct sock *exclude_sk; + u32 pid; + u32 group; + int failure; + int congested; + int delivered; + int allocation; + struct sk_buff *skb, *skb2; +}; + +static inline int do_one_broadcast(struct sock *sk, + struct netlink_broadcast_data *p) +{ + struct netlink_opt *nlk = nlk_sk(sk); + int val; + + if (p->exclude_sk == sk) + goto out; + + if (nlk->pid == p->pid || !(nlk->groups & p->group)) + goto out; + + if (p->failure) { + netlink_overrun(sk); + goto out; + } + + sock_hold(sk); + if (p->skb2 == NULL) { + if (atomic_read(&p->skb->users) != 1) { + p->skb2 = skb_clone(p->skb, p->allocation); + } else { + p->skb2 = p->skb; + atomic_inc(&p->skb->users); + } + } + if (p->skb2 == NULL) { + netlink_overrun(sk); + /* Clone failed. Notify ALL listeners. */ + p->failure = 1; + } else if ((val = netlink_broadcast_deliver(sk, p->skb2)) < 0) { + netlink_overrun(sk); + } else { + p->congested |= val; + p->delivered = 1; + p->skb2 = NULL; + } + sock_put(sk); + +out: + return 0; +} + int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, u32 pid, u32 group, int allocation) { - struct sock *sk; + struct netlink_broadcast_data info; struct hlist_node *node; - struct sk_buff *skb2 = NULL; - int protocol = ssk->sk_protocol; - int failure = 0, delivered = 0; - - /* While we sleep in clone, do not allow to change socket list */ + struct sock *sk; - netlink_lock_table(); + skb = netlink_trim(skb, allocation); - sk_for_each(sk, node, &nl_table[protocol]) { - struct netlink_opt *nlk = nlk_sk(sk); + info.exclude_sk = ssk; + info.pid = pid; + info.group = group; + info.failure = 0; + info.congested = 0; + info.delivered = 0; + info.allocation = allocation; + info.skb = skb; + info.skb2 = NULL; - if (ssk == sk) - continue; + /* While we sleep in clone, do not allow to change socket list */ - if (nlk->pid == pid || !(nlk->groups & group)) - continue; + netlink_lock_table(); - if (failure) { - netlink_overrun(sk); - continue; - } - - sock_hold(sk); - if (skb2 == NULL) { - if (atomic_read(&skb->users) != 1) { - skb2 = skb_clone(skb, allocation); - } else { - skb2 = skb; - atomic_inc(&skb->users); - } - } - if (skb2 == NULL) { - netlink_overrun(sk); - /* Clone failed. Notify ALL listeners. */ - failure = 1; - } else if (netlink_broadcast_deliver(sk, skb2)) { - netlink_overrun(sk); - } else { - delivered = 1; - skb2 = NULL; - } - sock_put(sk); - } + sk_for_each_bound(sk, node, &nl_table[ssk->sk_protocol].mc_list) + do_one_broadcast(sk, &info); netlink_unlock_table(); - if (skb2) - kfree_skb(skb2); + if (info.skb2) + kfree_skb(info.skb2); kfree_skb(skb); - if (delivered) + if (info.delivered) { + if (info.congested && (allocation & __GFP_WAIT)) + yield(); return 0; - if (failure) + } + if (info.failure) return -ENOBUFS; return -ESRCH; } +struct netlink_set_err_data { + struct sock *exclude_sk; + u32 pid; + u32 group; + int code; +}; + +static inline int do_one_set_err(struct sock *sk, + struct netlink_set_err_data *p) +{ + struct netlink_opt *nlk = nlk_sk(sk); + + if (sk == p->exclude_sk) + goto out; + + if (nlk->pid == p->pid || !(nlk->groups & p->group)) + goto out; + + sk->sk_err = p->code; + sk->sk_error_report(sk); +out: + return 0; +} + void netlink_set_err(struct sock *ssk, u32 pid, u32 group, int code) { - struct sock *sk; + struct netlink_set_err_data info; struct hlist_node *node; - int protocol = ssk->sk_protocol; + struct sock *sk; + + info.exclude_sk = ssk; + info.pid = pid; + info.group = group; + info.code = code; read_lock(&nl_table_lock); - sk_for_each(sk, node, &nl_table[protocol]) { - struct netlink_opt *nlk = nlk_sk(sk); - if (ssk == sk) - continue; - if (nlk->pid == pid || !(nlk->groups & group)) - continue; + sk_for_each_bound(sk, node, &nl_table[ssk->sk_protocol].mc_list) + do_one_set_err(sk, &info); - sk->sk_err = code; - sk->sk_error_report(sk); - } read_unlock(&nl_table_lock); } @@ -728,14 +939,14 @@ static int netlink_sendmsg(struct kiocb *kiocb, struct socket *sock, to corresponding kernel module. --ANK (980802) */ - err = security_netlink_send(skb); - if (err) { + err = -EFAULT; + if (memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len)) { kfree_skb(skb); goto out; } - err = -EFAULT; - if (memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len)) { + err = security_netlink_send(sk, skb); + if (err) { kfree_skb(skb); goto out; } @@ -830,6 +1041,9 @@ netlink_kernel_create(int unit, void (*input)(struct sock *sk, int len)) struct socket *sock; struct sock *sk; + if (!nl_table) + return NULL; + if (unit<0 || unit>=MAX_LINKS) return NULL; @@ -845,14 +1059,17 @@ netlink_kernel_create(int unit, void (*input)(struct sock *sk, int len)) if (input) nlk_sk(sk)->data_ready = input; - netlink_insert(sk, 0); + if (netlink_insert(sk, 0)) { + sock_release(sock); + return NULL; + } return sk; } -void netlink_set_nonroot(int protocol, unsigned flags) +void netlink_set_nonroot(int protocol, unsigned int flags) { - if ((unsigned)protocol < MAX_LINKS) - nl_nonroot[protocol] = flags; + if ((unsigned int)protocol < MAX_LINKS) + nl_table[protocol].nl_nonroot = flags; } static void netlink_destroy_callback(struct netlink_callback *cb) @@ -988,76 +1205,32 @@ void netlink_ack(struct sk_buff *in_skb, struct nlmsghdr *nlh, int err) } -#ifdef NL_EMULATE_DEV - -static rwlock_t nl_emu_lock = RW_LOCK_UNLOCKED; - -/* - * Backward compatibility. - */ - -int netlink_attach(int unit, int (*function)(int, struct sk_buff *skb)) -{ - struct sock *sk = netlink_kernel_create(unit, NULL); - if (sk == NULL) - return -ENOBUFS; - nlk_sk(sk)->handler = function; - write_lock_bh(&nl_emu_lock); - netlink_kernel[unit] = sk->sk_socket; - write_unlock_bh(&nl_emu_lock); - return 0; -} - -void netlink_detach(int unit) -{ - struct socket *sock; - - write_lock_bh(&nl_emu_lock); - sock = netlink_kernel[unit]; - netlink_kernel[unit] = NULL; - write_unlock_bh(&nl_emu_lock); - - sock_release(sock); -} - -int netlink_post(int unit, struct sk_buff *skb) -{ - struct socket *sock; - - read_lock(&nl_emu_lock); - sock = netlink_kernel[unit]; - if (sock) { - struct sock *sk = sock->sk; - memset(skb->cb, 0, sizeof(skb->cb)); - sock_hold(sk); - read_unlock(&nl_emu_lock); - - netlink_broadcast(sk, skb, 0, ~0, GFP_ATOMIC); - - sock_put(sk); - return 0; - } - read_unlock(&nl_emu_lock); - return -EUNATCH; -} - -#endif - #ifdef CONFIG_PROC_FS +struct nl_seq_iter { + int link; + int hash_idx; +}; + static struct sock *netlink_seq_socket_idx(struct seq_file *seq, loff_t pos) { - long i; + struct nl_seq_iter *iter = seq->private; + int i, j; struct sock *s; struct hlist_node *node; loff_t off = 0; for (i=0; iprivate = (void *) i; - return s; + struct nl_pid_hash *hash = &nl_table[i].hash; + + for (j = 0; j <= hash->mask; j++) { + sk_for_each(s, node, &hash->table[j]) { + if (off == pos) { + iter->link = i; + iter->hash_idx = j; + return s; + } + ++off; } - ++off; } } return NULL; @@ -1072,6 +1245,8 @@ static void *netlink_seq_start(struct seq_file *seq, loff_t *pos) static void *netlink_seq_next(struct seq_file *seq, void *v, loff_t *pos) { struct sock *s; + struct nl_seq_iter *iter; + int i, j; ++*pos; @@ -1079,18 +1254,29 @@ static void *netlink_seq_next(struct seq_file *seq, void *v, loff_t *pos) return netlink_seq_socket_idx(seq, 0); s = sk_next(v); - if (!s) { - long i = (long)seq->private; + if (s) + return s; + + iter = seq->private; + i = iter->link; + j = iter->hash_idx + 1; + + do { + struct nl_pid_hash *hash = &nl_table[i].hash; - while (++i < MAX_LINKS) { - s = sk_head(&nl_table[i]); + for (; j <= hash->mask; j++) { + s = sk_head(&hash->table[j]); if (s) { - seq->private = (void *) i; - break; + iter->link = i; + iter->hash_idx = j; + return s; } } - } - return s; + + j = 0; + } while (++i < MAX_LINKS); + + return NULL; } static void netlink_seq_stop(struct seq_file *seq, void *v) @@ -1134,7 +1320,24 @@ static struct seq_operations netlink_seq_ops = { static int netlink_seq_open(struct inode *inode, struct file *file) { - return seq_open(file, &netlink_seq_ops); + struct seq_file *seq; + struct nl_seq_iter *iter; + int err; + + iter = kmalloc(sizeof(*iter), GFP_KERNEL); + if (!iter) + return -ENOMEM; + + err = seq_open(file, &netlink_seq_ops); + if (err) { + kfree(iter); + return err; + } + + memset(iter, 0, sizeof(*iter)); + seq = file->private_data; + seq->private = iter; + return 0; } static struct file_operations netlink_seq_fops = { @@ -1142,7 +1345,7 @@ static struct file_operations netlink_seq_fops = { .open = netlink_seq_open, .read = seq_read, .llseek = seq_lseek, - .release = seq_release, + .release = seq_release_private, }; #endif @@ -1184,14 +1387,54 @@ static struct net_proto_family netlink_family_ops = { .owner = THIS_MODULE, /* for consistency 8) */ }; +extern void netlink_skb_parms_too_large(void); + static int __init netlink_proto_init(void) { struct sk_buff *dummy_skb; + int i; + unsigned long max; + unsigned int order; + + if (sizeof(struct netlink_skb_parms) > sizeof(dummy_skb->cb)) + netlink_skb_parms_too_large(); - if (sizeof(struct netlink_skb_parms) > sizeof(dummy_skb->cb)) { - printk(KERN_CRIT "netlink_init: panic\n"); - return -1; + nl_table = kmalloc(sizeof(*nl_table) * MAX_LINKS, GFP_KERNEL); + if (!nl_table) { +enomem: + printk(KERN_CRIT "netlink_init: Cannot allocate nl_table\n"); + return -ENOMEM; } + + memset(nl_table, 0, sizeof(*nl_table) * MAX_LINKS); + + if (num_physpages >= (128 * 1024)) + max = num_physpages >> (21 - PAGE_SHIFT); + else + max = num_physpages >> (23 - PAGE_SHIFT); + + order = get_bitmask_order(max) - 1 + PAGE_SHIFT; + max = (1UL << order) / sizeof(struct hlist_head); + order = get_bitmask_order(max > UINT_MAX ? UINT_MAX : max) - 1; + + for (i = 0; i < MAX_LINKS; i++) { + struct nl_pid_hash *hash = &nl_table[i].hash; + + hash->table = nl_pid_hash_alloc(1 * sizeof(*hash->table)); + if (!hash->table) { + while (i-- > 0) + nl_pid_hash_free(nl_table[i].hash.table, + 1 * sizeof(*hash->table)); + kfree(nl_table); + goto enomem; + } + memset(hash->table, 0, 1 * sizeof(*hash->table)); + hash->max_shift = order; + hash->shift = 0; + hash->mask = 0; + hash->rehash_time = jiffies; + } + sock_register(&netlink_family_ops); #ifdef CONFIG_PROC_FS proc_net_fops_create("netlink", 0, &netlink_seq_fops); @@ -1205,6 +1448,8 @@ static void __exit netlink_proto_exit(void) { sock_unregister(PF_NETLINK); proc_net_remove("netlink"); + kfree(nl_table); + nl_table = NULL; } core_initcall(netlink_proto_init); @@ -1216,7 +1461,6 @@ MODULE_ALIAS_NETPROTO(PF_NETLINK); EXPORT_SYMBOL(netlink_ack); EXPORT_SYMBOL(netlink_broadcast); -EXPORT_SYMBOL(netlink_broadcast_deliver); EXPORT_SYMBOL(netlink_dump_start); EXPORT_SYMBOL(netlink_kernel_create); EXPORT_SYMBOL(netlink_register_notifier); @@ -1225,8 +1469,3 @@ EXPORT_SYMBOL(netlink_set_nonroot); EXPORT_SYMBOL(netlink_unicast); EXPORT_SYMBOL(netlink_unregister_notifier); -#if defined(CONFIG_NETLINK_DEV) || defined(CONFIG_NETLINK_DEV_MODULE) -EXPORT_SYMBOL(netlink_attach); -EXPORT_SYMBOL(netlink_detach); -EXPORT_SYMBOL(netlink_post); -#endif