Eric Lee / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit c63d6ea3060d9e10773e869b1112e3a0efbcf820

Authored by Dan Carpenter
Committed by David S. Miller
1 parent 59deab26c1
Exists in master and in 38 other branches 8mp-imx_5.4.70_2.3.0, 8qm-imx_5.4.70_2.3.0, emb_imx_lf-5.15.y, emb_lf-6.1.y, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, imx_4.1.15_1.0.0_ga, pitx_8mp_lf-5.10.y, rt-smarc-imx_4.1.15_1.0.0_ga, rt_linux_5.15.71, smarc-8m-android-11.0.0_2.0.0, smarc-imx6_4.14.98_2.0.0_ga, smarc-imx6_4.9.88_2.0.0_ga, smarc-imx7_4.14.98_2.0.0_ga, smarc-imx7_4.9.11_1.0.0_ga, smarc-imx7_4.9.88_2.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-imx_4.1.15_1.0.0_ga, smarc-imx_4.9.11_1.0.0_ga, smarc-imx_4.9.51_imx8m_ga, smarc-imx_4.9.88_2.0.0_ga, smarc-m6.0.1_2.1.0-ga, smarc-n7.1.2_2.0.0-ga, smarc-rel_imx_4.1.15_1.2.0_ga, smarc_8m_00d0_imx_4.14.98_2.0.0_ga, smarc_8m_imx_4.14.78_1.0.0_ga, smarc_8m_imx_4.14.98_2.0.0_ga, smarc_8m_imx_4.19.35_1.1.0, smarc_8mm_imx_4.14.78_1.0.0_ga, smarc_8mm_imx_4.14.98_2.0.0_ga, smarc_8mm_imx_4.19.35_1.1.0, smarc_8mm_imx_5.4.24_2.1.0, smarc_8mp_lf-5.10.y, smarc_8mq_imx_5.4.24_2.1.0, smarc_8mq_lf-5.10.y, smarc_imx_lf-5.15.y

rtnetlink: unlock on error path in netlink_dump() 

In c7ac8679bec939 "rtnetlink: Compute and store minimum ifinfo dump
size", we moved the allocation under the lock so we need to unlock
on error path.

Signed-off-by: Dan Carpenter <error27@gmail.com>
Signed-off-by: David S. Miller <davem@conan.davemloft.net>

Showing 1 changed file with 1 additions and 2 deletions Inline Diff

net/netlink/af_netlink.c
Diff comments   View file @ c63d6ea
1 /* 1 /*
2 * NETLINK Kernel-user communication protocol. 2 * NETLINK Kernel-user communication protocol.
3 * 3 *
4 * Authors: Alan Cox <alan@lxorguk.ukuu.org.uk> 4 * Authors: Alan Cox <alan@lxorguk.ukuu.org.uk>
5 * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru> 5 * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
6 * 6 *
7 * This program is free software; you can redistribute it and/or 7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License 8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version. 10 * 2 of the License, or (at your option) any later version.
11 * 11 *
12 * Tue Jun 26 14:36:48 MEST 2001 Herbert "herp" Rosmanith 12 * Tue Jun 26 14:36:48 MEST 2001 Herbert "herp" Rosmanith
13 * added netlink_proto_exit 13 * added netlink_proto_exit
14 * Tue Jan 22 18:32:44 BRST 2002 Arnaldo C. de Melo <acme@conectiva.com.br> 14 * Tue Jan 22 18:32:44 BRST 2002 Arnaldo C. de Melo <acme@conectiva.com.br>
15 * use nlk_sk, as sk->protinfo is on a diet 8) 15 * use nlk_sk, as sk->protinfo is on a diet 8)
16 * Fri Jul 22 19:51:12 MEST 2005 Harald Welte <laforge@gnumonks.org> 16 * Fri Jul 22 19:51:12 MEST 2005 Harald Welte <laforge@gnumonks.org>
17 * - inc module use count of module that owns 17 * - inc module use count of module that owns
18 * the kernel socket in case userspace opens 18 * the kernel socket in case userspace opens
19 * socket of same protocol 19 * socket of same protocol
20 * - remove all module support, since netlink is 20 * - remove all module support, since netlink is
21 * mandatory if CONFIG_NET=y these days 21 * mandatory if CONFIG_NET=y these days
22 */ 22 */
23 23
24 #include <linux/module.h> 24 #include <linux/module.h>
25 25
26 #include <linux/capability.h> 26 #include <linux/capability.h>
27 #include <linux/kernel.h> 27 #include <linux/kernel.h>
28 #include <linux/init.h> 28 #include <linux/init.h>
29 #include <linux/signal.h> 29 #include <linux/signal.h>
30 #include <linux/sched.h> 30 #include <linux/sched.h>
31 #include <linux/errno.h> 31 #include <linux/errno.h>
32 #include <linux/string.h> 32 #include <linux/string.h>
33 #include <linux/stat.h> 33 #include <linux/stat.h>
34 #include <linux/socket.h> 34 #include <linux/socket.h>
35 #include <linux/un.h> 35 #include <linux/un.h>
36 #include <linux/fcntl.h> 36 #include <linux/fcntl.h>
37 #include <linux/termios.h> 37 #include <linux/termios.h>
38 #include <linux/sockios.h> 38 #include <linux/sockios.h>
39 #include <linux/net.h> 39 #include <linux/net.h>
40 #include <linux/fs.h> 40 #include <linux/fs.h>
41 #include <linux/slab.h> 41 #include <linux/slab.h>
42 #include <asm/uaccess.h> 42 #include <asm/uaccess.h>
43 #include <linux/skbuff.h> 43 #include <linux/skbuff.h>
44 #include <linux/netdevice.h> 44 #include <linux/netdevice.h>
45 #include <linux/rtnetlink.h> 45 #include <linux/rtnetlink.h>
46 #include <linux/proc_fs.h> 46 #include <linux/proc_fs.h>
47 #include <linux/seq_file.h> 47 #include <linux/seq_file.h>
48 #include <linux/notifier.h> 48 #include <linux/notifier.h>
49 #include <linux/security.h> 49 #include <linux/security.h>
50 #include <linux/jhash.h> 50 #include <linux/jhash.h>
51 #include <linux/jiffies.h> 51 #include <linux/jiffies.h>
52 #include <linux/random.h> 52 #include <linux/random.h>
53 #include <linux/bitops.h> 53 #include <linux/bitops.h>
54 #include <linux/mm.h> 54 #include <linux/mm.h>
55 #include <linux/types.h> 55 #include <linux/types.h>
56 #include <linux/audit.h> 56 #include <linux/audit.h>
57 #include <linux/mutex.h> 57 #include <linux/mutex.h>
58 58
59 #include <net/net_namespace.h> 59 #include <net/net_namespace.h>
60 #include <net/sock.h> 60 #include <net/sock.h>
61 #include <net/scm.h> 61 #include <net/scm.h>
62 #include <net/netlink.h> 62 #include <net/netlink.h>
63 63
64 #define NLGRPSZ(x) (ALIGN(x, sizeof(unsigned long) * 8) / 8) 64 #define NLGRPSZ(x) (ALIGN(x, sizeof(unsigned long) * 8) / 8)
65 #define NLGRPLONGS(x) (NLGRPSZ(x)/sizeof(unsigned long)) 65 #define NLGRPLONGS(x) (NLGRPSZ(x)/sizeof(unsigned long))
66 66
67 struct netlink_sock { 67 struct netlink_sock {
68 /* struct sock has to be the first member of netlink_sock */ 68 /* struct sock has to be the first member of netlink_sock */
69 struct sock sk; 69 struct sock sk;
70 u32 pid; 70 u32 pid;
71 u32 dst_pid; 71 u32 dst_pid;
72 u32 dst_group; 72 u32 dst_group;
73 u32 flags; 73 u32 flags;
74 u32 subscriptions; 74 u32 subscriptions;
75 u32 ngroups; 75 u32 ngroups;
76 unsigned long *groups; 76 unsigned long *groups;
77 unsigned long state; 77 unsigned long state;
78 wait_queue_head_t wait; 78 wait_queue_head_t wait;
79 struct netlink_callback *cb; 79 struct netlink_callback *cb;
80 struct mutex *cb_mutex; 80 struct mutex *cb_mutex;
81 struct mutex cb_def_mutex; 81 struct mutex cb_def_mutex;
82 void (*netlink_rcv)(struct sk_buff *skb); 82 void (*netlink_rcv)(struct sk_buff *skb);
83 struct module *module; 83 struct module *module;
84 }; 84 };
85 85
86 struct listeners { 86 struct listeners {
87 struct rcu_head rcu; 87 struct rcu_head rcu;
88 unsigned long masks[0]; 88 unsigned long masks[0];
89 }; 89 };
90 90
91 #define NETLINK_KERNEL_SOCKET 0x1 91 #define NETLINK_KERNEL_SOCKET 0x1
92 #define NETLINK_RECV_PKTINFO 0x2 92 #define NETLINK_RECV_PKTINFO 0x2
93 #define NETLINK_BROADCAST_SEND_ERROR 0x4 93 #define NETLINK_BROADCAST_SEND_ERROR 0x4
94 #define NETLINK_RECV_NO_ENOBUFS 0x8 94 #define NETLINK_RECV_NO_ENOBUFS 0x8
95 95
96 static inline struct netlink_sock *nlk_sk(struct sock *sk) 96 static inline struct netlink_sock *nlk_sk(struct sock *sk)
97 { 97 {
98 return container_of(sk, struct netlink_sock, sk); 98 return container_of(sk, struct netlink_sock, sk);
99 } 99 }
100 100
101 static inline int netlink_is_kernel(struct sock *sk) 101 static inline int netlink_is_kernel(struct sock *sk)
102 { 102 {
103 return nlk_sk(sk)->flags & NETLINK_KERNEL_SOCKET; 103 return nlk_sk(sk)->flags & NETLINK_KERNEL_SOCKET;
104 } 104 }
105 105
106 struct nl_pid_hash { 106 struct nl_pid_hash {
107 struct hlist_head *table; 107 struct hlist_head *table;
108 unsigned long rehash_time; 108 unsigned long rehash_time;
109 109
110 unsigned int mask; 110 unsigned int mask;
111 unsigned int shift; 111 unsigned int shift;
112 112
113 unsigned int entries; 113 unsigned int entries;
114 unsigned int max_shift; 114 unsigned int max_shift;
115 115
116 u32 rnd; 116 u32 rnd;
117 }; 117 };
118 118
119 struct netlink_table { 119 struct netlink_table {
120 struct nl_pid_hash hash; 120 struct nl_pid_hash hash;
121 struct hlist_head mc_list; 121 struct hlist_head mc_list;
122 struct listeners __rcu *listeners; 122 struct listeners __rcu *listeners;
123 unsigned int nl_nonroot; 123 unsigned int nl_nonroot;
124 unsigned int groups; 124 unsigned int groups;
125 struct mutex *cb_mutex; 125 struct mutex *cb_mutex;
126 struct module *module; 126 struct module *module;
127 int registered; 127 int registered;
128 }; 128 };
129 129
130 static struct netlink_table *nl_table; 130 static struct netlink_table *nl_table;
131 131
132 static DECLARE_WAIT_QUEUE_HEAD(nl_table_wait); 132 static DECLARE_WAIT_QUEUE_HEAD(nl_table_wait);
133 133
134 static int netlink_dump(struct sock *sk); 134 static int netlink_dump(struct sock *sk);
135 static void netlink_destroy_callback(struct netlink_callback *cb); 135 static void netlink_destroy_callback(struct netlink_callback *cb);
136 136
137 static DEFINE_RWLOCK(nl_table_lock); 137 static DEFINE_RWLOCK(nl_table_lock);
138 static atomic_t nl_table_users = ATOMIC_INIT(0); 138 static atomic_t nl_table_users = ATOMIC_INIT(0);
139 139
140 static ATOMIC_NOTIFIER_HEAD(netlink_chain); 140 static ATOMIC_NOTIFIER_HEAD(netlink_chain);
141 141
142 static u32 netlink_group_mask(u32 group) 142 static u32 netlink_group_mask(u32 group)
143 { 143 {
144 return group ? 1 << (group - 1) : 0; 144 return group ? 1 << (group - 1) : 0;
145 } 145 }
146 146
147 static struct hlist_head *nl_pid_hashfn(struct nl_pid_hash *hash, u32 pid) 147 static struct hlist_head *nl_pid_hashfn(struct nl_pid_hash *hash, u32 pid)
148 { 148 {
149 return &hash->table[jhash_1word(pid, hash->rnd) & hash->mask]; 149 return &hash->table[jhash_1word(pid, hash->rnd) & hash->mask];
150 } 150 }
151 151
152 static void netlink_sock_destruct(struct sock *sk) 152 static void netlink_sock_destruct(struct sock *sk)
153 { 153 {
154 struct netlink_sock *nlk = nlk_sk(sk); 154 struct netlink_sock *nlk = nlk_sk(sk);
155 155
156 if (nlk->cb) { 156 if (nlk->cb) {
157 if (nlk->cb->done) 157 if (nlk->cb->done)
158 nlk->cb->done(nlk->cb); 158 nlk->cb->done(nlk->cb);
159 netlink_destroy_callback(nlk->cb); 159 netlink_destroy_callback(nlk->cb);
160 } 160 }
161 161
162 skb_queue_purge(&sk->sk_receive_queue); 162 skb_queue_purge(&sk->sk_receive_queue);
163 163
164 if (!sock_flag(sk, SOCK_DEAD)) { 164 if (!sock_flag(sk, SOCK_DEAD)) {
165 printk(KERN_ERR "Freeing alive netlink socket %p\n", sk); 165 printk(KERN_ERR "Freeing alive netlink socket %p\n", sk);
166 return; 166 return;
167 } 167 }
168 168
169 WARN_ON(atomic_read(&sk->sk_rmem_alloc)); 169 WARN_ON(atomic_read(&sk->sk_rmem_alloc));
170 WARN_ON(atomic_read(&sk->sk_wmem_alloc)); 170 WARN_ON(atomic_read(&sk->sk_wmem_alloc));
171 WARN_ON(nlk_sk(sk)->groups); 171 WARN_ON(nlk_sk(sk)->groups);
172 } 172 }
173 173
174 /* This lock without WQ_FLAG_EXCLUSIVE is good on UP and it is _very_ bad on 174 /* This lock without WQ_FLAG_EXCLUSIVE is good on UP and it is _very_ bad on
175 * SMP. Look, when several writers sleep and reader wakes them up, all but one 175 * SMP. Look, when several writers sleep and reader wakes them up, all but one
176 * immediately hit write lock and grab all the cpus. Exclusive sleep solves 176 * immediately hit write lock and grab all the cpus. Exclusive sleep solves
177 * this, _but_ remember, it adds useless work on UP machines. 177 * this, _but_ remember, it adds useless work on UP machines.
178 */ 178 */
179 179
180 void netlink_table_grab(void) 180 void netlink_table_grab(void)
181 __acquires(nl_table_lock) 181 __acquires(nl_table_lock)
182 { 182 {
183 might_sleep(); 183 might_sleep();
184 184
185 write_lock_irq(&nl_table_lock); 185 write_lock_irq(&nl_table_lock);
186 186
187 if (atomic_read(&nl_table_users)) { 187 if (atomic_read(&nl_table_users)) {
188 DECLARE_WAITQUEUE(wait, current); 188 DECLARE_WAITQUEUE(wait, current);
189 189
190 add_wait_queue_exclusive(&nl_table_wait, &wait); 190 add_wait_queue_exclusive(&nl_table_wait, &wait);
191 for (;;) { 191 for (;;) {
192 set_current_state(TASK_UNINTERRUPTIBLE); 192 set_current_state(TASK_UNINTERRUPTIBLE);
193 if (atomic_read(&nl_table_users) == 0) 193 if (atomic_read(&nl_table_users) == 0)
194 break; 194 break;
195 write_unlock_irq(&nl_table_lock); 195 write_unlock_irq(&nl_table_lock);
196 schedule(); 196 schedule();
197 write_lock_irq(&nl_table_lock); 197 write_lock_irq(&nl_table_lock);
198 } 198 }
199 199
200 __set_current_state(TASK_RUNNING); 200 __set_current_state(TASK_RUNNING);
201 remove_wait_queue(&nl_table_wait, &wait); 201 remove_wait_queue(&nl_table_wait, &wait);
202 } 202 }
203 } 203 }
204 204
205 void netlink_table_ungrab(void) 205 void netlink_table_ungrab(void)
206 __releases(nl_table_lock) 206 __releases(nl_table_lock)
207 { 207 {
208 write_unlock_irq(&nl_table_lock); 208 write_unlock_irq(&nl_table_lock);
209 wake_up(&nl_table_wait); 209 wake_up(&nl_table_wait);
210 } 210 }
211 211
212 static inline void 212 static inline void
213 netlink_lock_table(void) 213 netlink_lock_table(void)
214 { 214 {
215 /* read_lock() synchronizes us to netlink_table_grab */ 215 /* read_lock() synchronizes us to netlink_table_grab */
216 216
217 read_lock(&nl_table_lock); 217 read_lock(&nl_table_lock);
218 atomic_inc(&nl_table_users); 218 atomic_inc(&nl_table_users);
219 read_unlock(&nl_table_lock); 219 read_unlock(&nl_table_lock);
220 } 220 }
221 221
222 static inline void 222 static inline void
223 netlink_unlock_table(void) 223 netlink_unlock_table(void)
224 { 224 {
225 if (atomic_dec_and_test(&nl_table_users)) 225 if (atomic_dec_and_test(&nl_table_users))
226 wake_up(&nl_table_wait); 226 wake_up(&nl_table_wait);
227 } 227 }
228 228
229 static inline struct sock *netlink_lookup(struct net *net, int protocol, 229 static inline struct sock *netlink_lookup(struct net *net, int protocol,
230 u32 pid) 230 u32 pid)
231 { 231 {
232 struct nl_pid_hash *hash = &nl_table[protocol].hash; 232 struct nl_pid_hash *hash = &nl_table[protocol].hash;
233 struct hlist_head *head; 233 struct hlist_head *head;
234 struct sock *sk; 234 struct sock *sk;
235 struct hlist_node *node; 235 struct hlist_node *node;
236 236
237 read_lock(&nl_table_lock); 237 read_lock(&nl_table_lock);
238 head = nl_pid_hashfn(hash, pid); 238 head = nl_pid_hashfn(hash, pid);
239 sk_for_each(sk, node, head) { 239 sk_for_each(sk, node, head) {
240 if (net_eq(sock_net(sk), net) && (nlk_sk(sk)->pid == pid)) { 240 if (net_eq(sock_net(sk), net) && (nlk_sk(sk)->pid == pid)) {
241 sock_hold(sk); 241 sock_hold(sk);
242 goto found; 242 goto found;
243 } 243 }
244 } 244 }
245 sk = NULL; 245 sk = NULL;
246 found: 246 found:
247 read_unlock(&nl_table_lock); 247 read_unlock(&nl_table_lock);
248 return sk; 248 return sk;
249 } 249 }
250 250
251 static inline struct hlist_head *nl_pid_hash_zalloc(size_t size) 251 static inline struct hlist_head *nl_pid_hash_zalloc(size_t size)
252 { 252 {
253 if (size <= PAGE_SIZE) 253 if (size <= PAGE_SIZE)
254 return kzalloc(size, GFP_ATOMIC); 254 return kzalloc(size, GFP_ATOMIC);
255 else 255 else
256 return (struct hlist_head *) 256 return (struct hlist_head *)
257 __get_free_pages(GFP_ATOMIC | __GFP_ZERO, 257 __get_free_pages(GFP_ATOMIC | __GFP_ZERO,
258 get_order(size)); 258 get_order(size));
259 } 259 }
260 260
261 static inline void nl_pid_hash_free(struct hlist_head *table, size_t size) 261 static inline void nl_pid_hash_free(struct hlist_head *table, size_t size)
262 { 262 {
263 if (size <= PAGE_SIZE) 263 if (size <= PAGE_SIZE)
264 kfree(table); 264 kfree(table);
265 else 265 else
266 free_pages((unsigned long)table, get_order(size)); 266 free_pages((unsigned long)table, get_order(size));
267 } 267 }
268 268
269 static int nl_pid_hash_rehash(struct nl_pid_hash *hash, int grow) 269 static int nl_pid_hash_rehash(struct nl_pid_hash *hash, int grow)
270 { 270 {
271 unsigned int omask, mask, shift; 271 unsigned int omask, mask, shift;
272 size_t osize, size; 272 size_t osize, size;
273 struct hlist_head *otable, *table; 273 struct hlist_head *otable, *table;
274 int i; 274 int i;
275 275
276 omask = mask = hash->mask; 276 omask = mask = hash->mask;
277 osize = size = (mask + 1) * sizeof(*table); 277 osize = size = (mask + 1) * sizeof(*table);
278 shift = hash->shift; 278 shift = hash->shift;
279 279
280 if (grow) { 280 if (grow) {
281 if (++shift > hash->max_shift) 281 if (++shift > hash->max_shift)
282 return 0; 282 return 0;
283 mask = mask * 2 + 1; 283 mask = mask * 2 + 1;
284 size *= 2; 284 size *= 2;
285 } 285 }
286 286
287 table = nl_pid_hash_zalloc(size); 287 table = nl_pid_hash_zalloc(size);
288 if (!table) 288 if (!table)
289 return 0; 289 return 0;
290 290
291 otable = hash->table; 291 otable = hash->table;
292 hash->table = table; 292 hash->table = table;
293 hash->mask = mask; 293 hash->mask = mask;
294 hash->shift = shift; 294 hash->shift = shift;
295 get_random_bytes(&hash->rnd, sizeof(hash->rnd)); 295 get_random_bytes(&hash->rnd, sizeof(hash->rnd));
296 296
297 for (i = 0; i <= omask; i++) { 297 for (i = 0; i <= omask; i++) {
298 struct sock *sk; 298 struct sock *sk;
299 struct hlist_node *node, *tmp; 299 struct hlist_node *node, *tmp;
300 300
301 sk_for_each_safe(sk, node, tmp, &otable[i]) 301 sk_for_each_safe(sk, node, tmp, &otable[i])
302 __sk_add_node(sk, nl_pid_hashfn(hash, nlk_sk(sk)->pid)); 302 __sk_add_node(sk, nl_pid_hashfn(hash, nlk_sk(sk)->pid));
303 } 303 }
304 304
305 nl_pid_hash_free(otable, osize); 305 nl_pid_hash_free(otable, osize);
306 hash->rehash_time = jiffies + 10 * 60 * HZ; 306 hash->rehash_time = jiffies + 10 * 60 * HZ;
307 return 1; 307 return 1;
308 } 308 }
309 309
310 static inline int nl_pid_hash_dilute(struct nl_pid_hash *hash, int len) 310 static inline int nl_pid_hash_dilute(struct nl_pid_hash *hash, int len)
311 { 311 {
312 int avg = hash->entries >> hash->shift; 312 int avg = hash->entries >> hash->shift;
313 313
314 if (unlikely(avg > 1) && nl_pid_hash_rehash(hash, 1)) 314 if (unlikely(avg > 1) && nl_pid_hash_rehash(hash, 1))
315 return 1; 315 return 1;
316 316
317 if (unlikely(len > avg) && time_after(jiffies, hash->rehash_time)) { 317 if (unlikely(len > avg) && time_after(jiffies, hash->rehash_time)) {
318 nl_pid_hash_rehash(hash, 0); 318 nl_pid_hash_rehash(hash, 0);
319 return 1; 319 return 1;
320 } 320 }
321 321
322 return 0; 322 return 0;
323 } 323 }
324 324
325 static const struct proto_ops netlink_ops; 325 static const struct proto_ops netlink_ops;
326 326
327 static void 327 static void
328 netlink_update_listeners(struct sock *sk) 328 netlink_update_listeners(struct sock *sk)
329 { 329 {
330 struct netlink_table *tbl = &nl_table[sk->sk_protocol]; 330 struct netlink_table *tbl = &nl_table[sk->sk_protocol];
331 struct hlist_node *node; 331 struct hlist_node *node;
332 unsigned long mask; 332 unsigned long mask;
333 unsigned int i; 333 unsigned int i;
334 334
335 for (i = 0; i < NLGRPLONGS(tbl->groups); i++) { 335 for (i = 0; i < NLGRPLONGS(tbl->groups); i++) {
336 mask = 0; 336 mask = 0;
337 sk_for_each_bound(sk, node, &tbl->mc_list) { 337 sk_for_each_bound(sk, node, &tbl->mc_list) {
338 if (i < NLGRPLONGS(nlk_sk(sk)->ngroups)) 338 if (i < NLGRPLONGS(nlk_sk(sk)->ngroups))
339 mask |= nlk_sk(sk)->groups[i]; 339 mask |= nlk_sk(sk)->groups[i];
340 } 340 }
341 tbl->listeners->masks[i] = mask; 341 tbl->listeners->masks[i] = mask;
342 } 342 }
343 /* this function is only called with the netlink table "grabbed", which 343 /* this function is only called with the netlink table "grabbed", which
344 * makes sure updates are visible before bind or setsockopt return. */ 344 * makes sure updates are visible before bind or setsockopt return. */
345 } 345 }
346 346
347 static int netlink_insert(struct sock *sk, struct net *net, u32 pid) 347 static int netlink_insert(struct sock *sk, struct net *net, u32 pid)
348 { 348 {
349 struct nl_pid_hash *hash = &nl_table[sk->sk_protocol].hash; 349 struct nl_pid_hash *hash = &nl_table[sk->sk_protocol].hash;
350 struct hlist_head *head; 350 struct hlist_head *head;
351 int err = -EADDRINUSE; 351 int err = -EADDRINUSE;
352 struct sock *osk; 352 struct sock *osk;
353 struct hlist_node *node; 353 struct hlist_node *node;
354 int len; 354 int len;
355 355
356 netlink_table_grab(); 356 netlink_table_grab();
357 head = nl_pid_hashfn(hash, pid); 357 head = nl_pid_hashfn(hash, pid);
358 len = 0; 358 len = 0;
359 sk_for_each(osk, node, head) { 359 sk_for_each(osk, node, head) {
360 if (net_eq(sock_net(osk), net) && (nlk_sk(osk)->pid == pid)) 360 if (net_eq(sock_net(osk), net) && (nlk_sk(osk)->pid == pid))
361 break; 361 break;
362 len++; 362 len++;
363 } 363 }
364 if (node) 364 if (node)
365 goto err; 365 goto err;
366 366
367 err = -EBUSY; 367 err = -EBUSY;
368 if (nlk_sk(sk)->pid) 368 if (nlk_sk(sk)->pid)
369 goto err; 369 goto err;
370 370
371 err = -ENOMEM; 371 err = -ENOMEM;
372 if (BITS_PER_LONG > 32 && unlikely(hash->entries >= UINT_MAX)) 372 if (BITS_PER_LONG > 32 && unlikely(hash->entries >= UINT_MAX))
373 goto err; 373 goto err;
374 374
375 if (len && nl_pid_hash_dilute(hash, len)) 375 if (len && nl_pid_hash_dilute(hash, len))
376 head = nl_pid_hashfn(hash, pid); 376 head = nl_pid_hashfn(hash, pid);
377 hash->entries++; 377 hash->entries++;
378 nlk_sk(sk)->pid = pid; 378 nlk_sk(sk)->pid = pid;
379 sk_add_node(sk, head); 379 sk_add_node(sk, head);
380 err = 0; 380 err = 0;
381 381
382 err: 382 err:
383 netlink_table_ungrab(); 383 netlink_table_ungrab();
384 return err; 384 return err;
385 } 385 }
386 386
387 static void netlink_remove(struct sock *sk) 387 static void netlink_remove(struct sock *sk)
388 { 388 {
389 netlink_table_grab(); 389 netlink_table_grab();
390 if (sk_del_node_init(sk)) 390 if (sk_del_node_init(sk))
391 nl_table[sk->sk_protocol].hash.entries--; 391 nl_table[sk->sk_protocol].hash.entries--;
392 if (nlk_sk(sk)->subscriptions) 392 if (nlk_sk(sk)->subscriptions)
393 __sk_del_bind_node(sk); 393 __sk_del_bind_node(sk);
394 netlink_table_ungrab(); 394 netlink_table_ungrab();
395 } 395 }
396 396
397 static struct proto netlink_proto = { 397 static struct proto netlink_proto = {
398 .name = "NETLINK", 398 .name = "NETLINK",
399 .owner = THIS_MODULE, 399 .owner = THIS_MODULE,
400 .obj_size = sizeof(struct netlink_sock), 400 .obj_size = sizeof(struct netlink_sock),
401 }; 401 };
402 402
403 static int __netlink_create(struct net *net, struct socket *sock, 403 static int __netlink_create(struct net *net, struct socket *sock,
404 struct mutex *cb_mutex, int protocol) 404 struct mutex *cb_mutex, int protocol)
405 { 405 {
406 struct sock *sk; 406 struct sock *sk;
407 struct netlink_sock *nlk; 407 struct netlink_sock *nlk;
408 408
409 sock->ops = &netlink_ops; 409 sock->ops = &netlink_ops;
410 410
411 sk = sk_alloc(net, PF_NETLINK, GFP_KERNEL, &netlink_proto); 411 sk = sk_alloc(net, PF_NETLINK, GFP_KERNEL, &netlink_proto);
412 if (!sk) 412 if (!sk)
413 return -ENOMEM; 413 return -ENOMEM;
414 414
415 sock_init_data(sock, sk); 415 sock_init_data(sock, sk);
416 416
417 nlk = nlk_sk(sk); 417 nlk = nlk_sk(sk);
418 if (cb_mutex) 418 if (cb_mutex)
419 nlk->cb_mutex = cb_mutex; 419 nlk->cb_mutex = cb_mutex;
420 else { 420 else {
421 nlk->cb_mutex = &nlk->cb_def_mutex; 421 nlk->cb_mutex = &nlk->cb_def_mutex;
422 mutex_init(nlk->cb_mutex); 422 mutex_init(nlk->cb_mutex);
423 } 423 }
424 init_waitqueue_head(&nlk->wait); 424 init_waitqueue_head(&nlk->wait);
425 425
426 sk->sk_destruct = netlink_sock_destruct; 426 sk->sk_destruct = netlink_sock_destruct;
427 sk->sk_protocol = protocol; 427 sk->sk_protocol = protocol;
428 return 0; 428 return 0;
429 } 429 }
430 430
431 static int netlink_create(struct net *net, struct socket *sock, int protocol, 431 static int netlink_create(struct net *net, struct socket *sock, int protocol,
432 int kern) 432 int kern)
433 { 433 {
434 struct module *module = NULL; 434 struct module *module = NULL;
435 struct mutex *cb_mutex; 435 struct mutex *cb_mutex;
436 struct netlink_sock *nlk; 436 struct netlink_sock *nlk;
437 int err = 0; 437 int err = 0;
438 438
439 sock->state = SS_UNCONNECTED; 439 sock->state = SS_UNCONNECTED;
440 440
441 if (sock->type != SOCK_RAW && sock->type != SOCK_DGRAM) 441 if (sock->type != SOCK_RAW && sock->type != SOCK_DGRAM)
442 return -ESOCKTNOSUPPORT; 442 return -ESOCKTNOSUPPORT;
443 443
444 if (protocol < 0 || protocol >= MAX_LINKS) 444 if (protocol < 0 || protocol >= MAX_LINKS)
445 return -EPROTONOSUPPORT; 445 return -EPROTONOSUPPORT;
446 446
447 netlink_lock_table(); 447 netlink_lock_table();
448 #ifdef CONFIG_MODULES 448 #ifdef CONFIG_MODULES
449 if (!nl_table[protocol].registered) { 449 if (!nl_table[protocol].registered) {
450 netlink_unlock_table(); 450 netlink_unlock_table();
451 request_module("net-pf-%d-proto-%d", PF_NETLINK, protocol); 451 request_module("net-pf-%d-proto-%d", PF_NETLINK, protocol);
452 netlink_lock_table(); 452 netlink_lock_table();
453 } 453 }
454 #endif 454 #endif
455 if (nl_table[protocol].registered && 455 if (nl_table[protocol].registered &&
456 try_module_get(nl_table[protocol].module)) 456 try_module_get(nl_table[protocol].module))
457 module = nl_table[protocol].module; 457 module = nl_table[protocol].module;
458 else 458 else
459 err = -EPROTONOSUPPORT; 459 err = -EPROTONOSUPPORT;
460 cb_mutex = nl_table[protocol].cb_mutex; 460 cb_mutex = nl_table[protocol].cb_mutex;
461 netlink_unlock_table(); 461 netlink_unlock_table();
462 462
463 if (err < 0) 463 if (err < 0)
464 goto out; 464 goto out;
465 465
466 err = __netlink_create(net, sock, cb_mutex, protocol); 466 err = __netlink_create(net, sock, cb_mutex, protocol);
467 if (err < 0) 467 if (err < 0)
468 goto out_module; 468 goto out_module;
469 469
470 local_bh_disable(); 470 local_bh_disable();
471 sock_prot_inuse_add(net, &netlink_proto, 1); 471 sock_prot_inuse_add(net, &netlink_proto, 1);
472 local_bh_enable(); 472 local_bh_enable();
473 473
474 nlk = nlk_sk(sock->sk); 474 nlk = nlk_sk(sock->sk);
475 nlk->module = module; 475 nlk->module = module;
476 out: 476 out:
477 return err; 477 return err;
478 478
479 out_module: 479 out_module:
480 module_put(module); 480 module_put(module);
481 goto out; 481 goto out;
482 } 482 }
483 483
484 static int netlink_release(struct socket *sock) 484 static int netlink_release(struct socket *sock)
485 { 485 {
486 struct sock *sk = sock->sk; 486 struct sock *sk = sock->sk;
487 struct netlink_sock *nlk; 487 struct netlink_sock *nlk;
488 488
489 if (!sk) 489 if (!sk)
490 return 0; 490 return 0;
491 491
492 netlink_remove(sk); 492 netlink_remove(sk);
493 sock_orphan(sk); 493 sock_orphan(sk);
494 nlk = nlk_sk(sk); 494 nlk = nlk_sk(sk);
495 495
496 /* 496 /*
497 * OK. Socket is unlinked, any packets that arrive now 497 * OK. Socket is unlinked, any packets that arrive now
498 * will be purged. 498 * will be purged.
499 */ 499 */
500 500
501 sock->sk = NULL; 501 sock->sk = NULL;
502 wake_up_interruptible_all(&nlk->wait); 502 wake_up_interruptible_all(&nlk->wait);
503 503
504 skb_queue_purge(&sk->sk_write_queue); 504 skb_queue_purge(&sk->sk_write_queue);
505 505
506 if (nlk->pid) { 506 if (nlk->pid) {
507 struct netlink_notify n = { 507 struct netlink_notify n = {
508 .net = sock_net(sk), 508 .net = sock_net(sk),
509 .protocol = sk->sk_protocol, 509 .protocol = sk->sk_protocol,
510 .pid = nlk->pid, 510 .pid = nlk->pid,
511 }; 511 };
512 atomic_notifier_call_chain(&netlink_chain, 512 atomic_notifier_call_chain(&netlink_chain,
513 NETLINK_URELEASE, &n); 513 NETLINK_URELEASE, &n);
514 } 514 }
515 515
516 module_put(nlk->module); 516 module_put(nlk->module);
517 517
518 netlink_table_grab(); 518 netlink_table_grab();
519 if (netlink_is_kernel(sk)) { 519 if (netlink_is_kernel(sk)) {
520 BUG_ON(nl_table[sk->sk_protocol].registered == 0); 520 BUG_ON(nl_table[sk->sk_protocol].registered == 0);
521 if (--nl_table[sk->sk_protocol].registered == 0) { 521 if (--nl_table[sk->sk_protocol].registered == 0) {
522 kfree(nl_table[sk->sk_protocol].listeners); 522 kfree(nl_table[sk->sk_protocol].listeners);
523 nl_table[sk->sk_protocol].module = NULL; 523 nl_table[sk->sk_protocol].module = NULL;
524 nl_table[sk->sk_protocol].registered = 0; 524 nl_table[sk->sk_protocol].registered = 0;
525 } 525 }
526 } else if (nlk->subscriptions) 526 } else if (nlk->subscriptions)
527 netlink_update_listeners(sk); 527 netlink_update_listeners(sk);
528 netlink_table_ungrab(); 528 netlink_table_ungrab();
529 529
530 kfree(nlk->groups); 530 kfree(nlk->groups);
531 nlk->groups = NULL; 531 nlk->groups = NULL;
532 532
533 local_bh_disable(); 533 local_bh_disable();
534 sock_prot_inuse_add(sock_net(sk), &netlink_proto, -1); 534 sock_prot_inuse_add(sock_net(sk), &netlink_proto, -1);
535 local_bh_enable(); 535 local_bh_enable();
536 sock_put(sk); 536 sock_put(sk);
537 return 0; 537 return 0;
538 } 538 }
539 539
540 static int netlink_autobind(struct socket *sock) 540 static int netlink_autobind(struct socket *sock)
541 { 541 {
542 struct sock *sk = sock->sk; 542 struct sock *sk = sock->sk;
543 struct net *net = sock_net(sk); 543 struct net *net = sock_net(sk);
544 struct nl_pid_hash *hash = &nl_table[sk->sk_protocol].hash; 544 struct nl_pid_hash *hash = &nl_table[sk->sk_protocol].hash;
545 struct hlist_head *head; 545 struct hlist_head *head;
546 struct sock *osk; 546 struct sock *osk;
547 struct hlist_node *node; 547 struct hlist_node *node;
548 s32 pid = task_tgid_vnr(current); 548 s32 pid = task_tgid_vnr(current);
549 int err; 549 int err;
550 static s32 rover = -4097; 550 static s32 rover = -4097;
551 551
552 retry: 552 retry:
553 cond_resched(); 553 cond_resched();
554 netlink_table_grab(); 554 netlink_table_grab();
555 head = nl_pid_hashfn(hash, pid); 555 head = nl_pid_hashfn(hash, pid);
556 sk_for_each(osk, node, head) { 556 sk_for_each(osk, node, head) {
557 if (!net_eq(sock_net(osk), net)) 557 if (!net_eq(sock_net(osk), net))
558 continue; 558 continue;
559 if (nlk_sk(osk)->pid == pid) { 559 if (nlk_sk(osk)->pid == pid) {
560 /* Bind collision, search negative pid values. */ 560 /* Bind collision, search negative pid values. */
561 pid = rover--; 561 pid = rover--;
562 if (rover > -4097) 562 if (rover > -4097)
563 rover = -4097; 563 rover = -4097;
564 netlink_table_ungrab(); 564 netlink_table_ungrab();
565 goto retry; 565 goto retry;
566 } 566 }
567 } 567 }
568 netlink_table_ungrab(); 568 netlink_table_ungrab();
569 569
570 err = netlink_insert(sk, net, pid); 570 err = netlink_insert(sk, net, pid);
571 if (err == -EADDRINUSE) 571 if (err == -EADDRINUSE)
572 goto retry; 572 goto retry;
573 573
574 /* If 2 threads race to autobind, that is fine. */ 574 /* If 2 threads race to autobind, that is fine. */
575 if (err == -EBUSY) 575 if (err == -EBUSY)
576 err = 0; 576 err = 0;
577 577
578 return err; 578 return err;
579 } 579 }
580 580
581 static inline int netlink_capable(struct socket *sock, unsigned int flag) 581 static inline int netlink_capable(struct socket *sock, unsigned int flag)
582 { 582 {
583 return (nl_table[sock->sk->sk_protocol].nl_nonroot & flag) || 583 return (nl_table[sock->sk->sk_protocol].nl_nonroot & flag) ||
584 capable(CAP_NET_ADMIN); 584 capable(CAP_NET_ADMIN);
585 } 585 }
586 586
587 static void 587 static void
588 netlink_update_subscriptions(struct sock *sk, unsigned int subscriptions) 588 netlink_update_subscriptions(struct sock *sk, unsigned int subscriptions)
589 { 589 {
590 struct netlink_sock *nlk = nlk_sk(sk); 590 struct netlink_sock *nlk = nlk_sk(sk);
591 591
592 if (nlk->subscriptions && !subscriptions) 592 if (nlk->subscriptions && !subscriptions)
593 __sk_del_bind_node(sk); 593 __sk_del_bind_node(sk);
594 else if (!nlk->subscriptions && subscriptions) 594 else if (!nlk->subscriptions && subscriptions)
595 sk_add_bind_node(sk, &nl_table[sk->sk_protocol].mc_list); 595 sk_add_bind_node(sk, &nl_table[sk->sk_protocol].mc_list);
596 nlk->subscriptions = subscriptions; 596 nlk->subscriptions = subscriptions;
597 } 597 }
598 598
599 static int netlink_realloc_groups(struct sock *sk) 599 static int netlink_realloc_groups(struct sock *sk)
600 { 600 {
601 struct netlink_sock *nlk = nlk_sk(sk); 601 struct netlink_sock *nlk = nlk_sk(sk);
602 unsigned int groups; 602 unsigned int groups;
603 unsigned long *new_groups; 603 unsigned long *new_groups;
604 int err = 0; 604 int err = 0;
605 605
606 netlink_table_grab(); 606 netlink_table_grab();
607 607
608 groups = nl_table[sk->sk_protocol].groups; 608 groups = nl_table[sk->sk_protocol].groups;
609 if (!nl_table[sk->sk_protocol].registered) { 609 if (!nl_table[sk->sk_protocol].registered) {
610 err = -ENOENT; 610 err = -ENOENT;
611 goto out_unlock; 611 goto out_unlock;
612 } 612 }
613 613
614 if (nlk->ngroups >= groups) 614 if (nlk->ngroups >= groups)
615 goto out_unlock; 615 goto out_unlock;
616 616
617 new_groups = krealloc(nlk->groups, NLGRPSZ(groups), GFP_ATOMIC); 617 new_groups = krealloc(nlk->groups, NLGRPSZ(groups), GFP_ATOMIC);
618 if (new_groups == NULL) { 618 if (new_groups == NULL) {
619 err = -ENOMEM; 619 err = -ENOMEM;
620 goto out_unlock; 620 goto out_unlock;
621 } 621 }
622 memset((char *)new_groups + NLGRPSZ(nlk->ngroups), 0, 622 memset((char *)new_groups + NLGRPSZ(nlk->ngroups), 0,
623 NLGRPSZ(groups) - NLGRPSZ(nlk->ngroups)); 623 NLGRPSZ(groups) - NLGRPSZ(nlk->ngroups));
624 624
625 nlk->groups = new_groups; 625 nlk->groups = new_groups;
626 nlk->ngroups = groups; 626 nlk->ngroups = groups;
627 out_unlock: 627 out_unlock:
628 netlink_table_ungrab(); 628 netlink_table_ungrab();
629 return err; 629 return err;
630 } 630 }
631 631
632 static int netlink_bind(struct socket *sock, struct sockaddr *addr, 632 static int netlink_bind(struct socket *sock, struct sockaddr *addr,
633 int addr_len) 633 int addr_len)
634 { 634 {
635 struct sock *sk = sock->sk; 635 struct sock *sk = sock->sk;
636 struct net *net = sock_net(sk); 636 struct net *net = sock_net(sk);
637 struct netlink_sock *nlk = nlk_sk(sk); 637 struct netlink_sock *nlk = nlk_sk(sk);
638 struct sockaddr_nl *nladdr = (struct sockaddr_nl *)addr; 638 struct sockaddr_nl *nladdr = (struct sockaddr_nl *)addr;
639 int err; 639 int err;
640 640
641 if (nladdr->nl_family != AF_NETLINK) 641 if (nladdr->nl_family != AF_NETLINK)
642 return -EINVAL; 642 return -EINVAL;
643 643
644 /* Only superuser is allowed to listen multicasts */ 644 /* Only superuser is allowed to listen multicasts */
645 if (nladdr->nl_groups) { 645 if (nladdr->nl_groups) {
646 if (!netlink_capable(sock, NL_NONROOT_RECV)) 646 if (!netlink_capable(sock, NL_NONROOT_RECV))
647 return -EPERM; 647 return -EPERM;
648 err = netlink_realloc_groups(sk); 648 err = netlink_realloc_groups(sk);
649 if (err) 649 if (err)
650 return err; 650 return err;
651 } 651 }
652 652
653 if (nlk->pid) { 653 if (nlk->pid) {
654 if (nladdr->nl_pid != nlk->pid) 654 if (nladdr->nl_pid != nlk->pid)
655 return -EINVAL; 655 return -EINVAL;
656 } else { 656 } else {
657 err = nladdr->nl_pid ? 657 err = nladdr->nl_pid ?
658 netlink_insert(sk, net, nladdr->nl_pid) : 658 netlink_insert(sk, net, nladdr->nl_pid) :
659 netlink_autobind(sock); 659 netlink_autobind(sock);
660 if (err) 660 if (err)
661 return err; 661 return err;
662 } 662 }
663 663
664 if (!nladdr->nl_groups && (nlk->groups == NULL || !(u32)nlk->groups[0])) 664 if (!nladdr->nl_groups && (nlk->groups == NULL || !(u32)nlk->groups[0]))
665 return 0; 665 return 0;
666 666
667 netlink_table_grab(); 667 netlink_table_grab();
668 netlink_update_subscriptions(sk, nlk->subscriptions + 668 netlink_update_subscriptions(sk, nlk->subscriptions +
669 hweight32(nladdr->nl_groups) - 669 hweight32(nladdr->nl_groups) -
670 hweight32(nlk->groups[0])); 670 hweight32(nlk->groups[0]));
671 nlk->groups[0] = (nlk->groups[0] & ~0xffffffffUL) | nladdr->nl_groups; 671 nlk->groups[0] = (nlk->groups[0] & ~0xffffffffUL) | nladdr->nl_groups;
672 netlink_update_listeners(sk); 672 netlink_update_listeners(sk);
673 netlink_table_ungrab(); 673 netlink_table_ungrab();
674 674
675 return 0; 675 return 0;
676 } 676 }
677 677
678 static int netlink_connect(struct socket *sock, struct sockaddr *addr, 678 static int netlink_connect(struct socket *sock, struct sockaddr *addr,
679 int alen, int flags) 679 int alen, int flags)
680 { 680 {
681 int err = 0; 681 int err = 0;
682 struct sock *sk = sock->sk; 682 struct sock *sk = sock->sk;
683 struct netlink_sock *nlk = nlk_sk(sk); 683 struct netlink_sock *nlk = nlk_sk(sk);
684 struct sockaddr_nl *nladdr = (struct sockaddr_nl *)addr; 684 struct sockaddr_nl *nladdr = (struct sockaddr_nl *)addr;
685 685
686 if (alen < sizeof(addr->sa_family)) 686 if (alen < sizeof(addr->sa_family))
687 return -EINVAL; 687 return -EINVAL;
688 688
689 if (addr->sa_family == AF_UNSPEC) { 689 if (addr->sa_family == AF_UNSPEC) {
690 sk->sk_state = NETLINK_UNCONNECTED; 690 sk->sk_state = NETLINK_UNCONNECTED;
691 nlk->dst_pid = 0; 691 nlk->dst_pid = 0;
692 nlk->dst_group = 0; 692 nlk->dst_group = 0;
693 return 0; 693 return 0;
694 } 694 }
695 if (addr->sa_family != AF_NETLINK) 695 if (addr->sa_family != AF_NETLINK)
696 return -EINVAL; 696 return -EINVAL;
697 697
698 /* Only superuser is allowed to send multicasts */ 698 /* Only superuser is allowed to send multicasts */
699 if (nladdr->nl_groups && !netlink_capable(sock, NL_NONROOT_SEND)) 699 if (nladdr->nl_groups && !netlink_capable(sock, NL_NONROOT_SEND))
700 return -EPERM; 700 return -EPERM;
701 701
702 if (!nlk->pid) 702 if (!nlk->pid)
703 err = netlink_autobind(sock); 703 err = netlink_autobind(sock);
704 704
705 if (err == 0) { 705 if (err == 0) {
706 sk->sk_state = NETLINK_CONNECTED; 706 sk->sk_state = NETLINK_CONNECTED;
707 nlk->dst_pid = nladdr->nl_pid; 707 nlk->dst_pid = nladdr->nl_pid;
708 nlk->dst_group = ffs(nladdr->nl_groups); 708 nlk->dst_group = ffs(nladdr->nl_groups);
709 } 709 }
710 710
711 return err; 711 return err;
712 } 712 }
713 713
714 static int netlink_getname(struct socket *sock, struct sockaddr *addr, 714 static int netlink_getname(struct socket *sock, struct sockaddr *addr,
715 int *addr_len, int peer) 715 int *addr_len, int peer)
716 { 716 {
717 struct sock *sk = sock->sk; 717 struct sock *sk = sock->sk;
718 struct netlink_sock *nlk = nlk_sk(sk); 718 struct netlink_sock *nlk = nlk_sk(sk);
719 DECLARE_SOCKADDR(struct sockaddr_nl *, nladdr, addr); 719 DECLARE_SOCKADDR(struct sockaddr_nl *, nladdr, addr);
720 720
721 nladdr->nl_family = AF_NETLINK; 721 nladdr->nl_family = AF_NETLINK;
722 nladdr->nl_pad = 0; 722 nladdr->nl_pad = 0;
723 *addr_len = sizeof(*nladdr); 723 *addr_len = sizeof(*nladdr);
724 724
725 if (peer) { 725 if (peer) {
726 nladdr->nl_pid = nlk->dst_pid; 726 nladdr->nl_pid = nlk->dst_pid;
727 nladdr->nl_groups = netlink_group_mask(nlk->dst_group); 727 nladdr->nl_groups = netlink_group_mask(nlk->dst_group);
728 } else { 728 } else {
729 nladdr->nl_pid = nlk->pid; 729 nladdr->nl_pid = nlk->pid;
730 nladdr->nl_groups = nlk->groups ? nlk->groups[0] : 0; 730 nladdr->nl_groups = nlk->groups ? nlk->groups[0] : 0;
731 } 731 }
732 return 0; 732 return 0;
733 } 733 }
734 734
735 static void netlink_overrun(struct sock *sk) 735 static void netlink_overrun(struct sock *sk)
736 { 736 {
737 struct netlink_sock *nlk = nlk_sk(sk); 737 struct netlink_sock *nlk = nlk_sk(sk);
738 738
739 if (!(nlk->flags & NETLINK_RECV_NO_ENOBUFS)) { 739 if (!(nlk->flags & NETLINK_RECV_NO_ENOBUFS)) {
740 if (!test_and_set_bit(0, &nlk_sk(sk)->state)) { 740 if (!test_and_set_bit(0, &nlk_sk(sk)->state)) {
741 sk->sk_err = ENOBUFS; 741 sk->sk_err = ENOBUFS;
742 sk->sk_error_report(sk); 742 sk->sk_error_report(sk);
743 } 743 }
744 } 744 }
745 atomic_inc(&sk->sk_drops); 745 atomic_inc(&sk->sk_drops);
746 } 746 }
747 747
748 static struct sock *netlink_getsockbypid(struct sock *ssk, u32 pid) 748 static struct sock *netlink_getsockbypid(struct sock *ssk, u32 pid)
749 { 749 {
750 struct sock *sock; 750 struct sock *sock;
751 struct netlink_sock *nlk; 751 struct netlink_sock *nlk;
752 752
753 sock = netlink_lookup(sock_net(ssk), ssk->sk_protocol, pid); 753 sock = netlink_lookup(sock_net(ssk), ssk->sk_protocol, pid);
754 if (!sock) 754 if (!sock)
755 return ERR_PTR(-ECONNREFUSED); 755 return ERR_PTR(-ECONNREFUSED);
756 756
757 /* Don't bother queuing skb if kernel socket has no input function */ 757 /* Don't bother queuing skb if kernel socket has no input function */
758 nlk = nlk_sk(sock); 758 nlk = nlk_sk(sock);
759 if (sock->sk_state == NETLINK_CONNECTED && 759 if (sock->sk_state == NETLINK_CONNECTED &&
760 nlk->dst_pid != nlk_sk(ssk)->pid) { 760 nlk->dst_pid != nlk_sk(ssk)->pid) {
761 sock_put(sock); 761 sock_put(sock);
762 return ERR_PTR(-ECONNREFUSED); 762 return ERR_PTR(-ECONNREFUSED);
763 } 763 }
764 return sock; 764 return sock;
765 } 765 }
766 766
767 struct sock *netlink_getsockbyfilp(struct file *filp) 767 struct sock *netlink_getsockbyfilp(struct file *filp)
768 { 768 {
769 struct inode *inode = filp->f_path.dentry->d_inode; 769 struct inode *inode = filp->f_path.dentry->d_inode;
770 struct sock *sock; 770 struct sock *sock;
771 771
772 if (!S_ISSOCK(inode->i_mode)) 772 if (!S_ISSOCK(inode->i_mode))
773 return ERR_PTR(-ENOTSOCK); 773 return ERR_PTR(-ENOTSOCK);
774 774
775 sock = SOCKET_I(inode)->sk; 775 sock = SOCKET_I(inode)->sk;
776 if (sock->sk_family != AF_NETLINK) 776 if (sock->sk_family != AF_NETLINK)
777 return ERR_PTR(-EINVAL); 777 return ERR_PTR(-EINVAL);
778 778
779 sock_hold(sock); 779 sock_hold(sock);
780 return sock; 780 return sock;
781 } 781 }
782 782
783 /* 783 /*
784 * Attach a skb to a netlink socket. 784 * Attach a skb to a netlink socket.
785 * The caller must hold a reference to the destination socket. On error, the 785 * The caller must hold a reference to the destination socket. On error, the
786 * reference is dropped. The skb is not send to the destination, just all 786 * reference is dropped. The skb is not send to the destination, just all
787 * all error checks are performed and memory in the queue is reserved. 787 * all error checks are performed and memory in the queue is reserved.
788 * Return values: 788 * Return values:
789 * < 0: error. skb freed, reference to sock dropped. 789 * < 0: error. skb freed, reference to sock dropped.
790 * 0: continue 790 * 0: continue
791 * 1: repeat lookup - reference dropped while waiting for socket memory. 791 * 1: repeat lookup - reference dropped while waiting for socket memory.
792 */ 792 */
793 int netlink_attachskb(struct sock *sk, struct sk_buff *skb, 793 int netlink_attachskb(struct sock *sk, struct sk_buff *skb,
794 long *timeo, struct sock *ssk) 794 long *timeo, struct sock *ssk)
795 { 795 {
796 struct netlink_sock *nlk; 796 struct netlink_sock *nlk;
797 797
798 nlk = nlk_sk(sk); 798 nlk = nlk_sk(sk);
799 799
800 if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf || 800 if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
801 test_bit(0, &nlk->state)) { 801 test_bit(0, &nlk->state)) {
802 DECLARE_WAITQUEUE(wait, current); 802 DECLARE_WAITQUEUE(wait, current);
803 if (!*timeo) { 803 if (!*timeo) {
804 if (!ssk || netlink_is_kernel(ssk)) 804 if (!ssk || netlink_is_kernel(ssk))
805 netlink_overrun(sk); 805 netlink_overrun(sk);
806 sock_put(sk); 806 sock_put(sk);
807 kfree_skb(skb); 807 kfree_skb(skb);
808 return -EAGAIN; 808 return -EAGAIN;
809 } 809 }
810 810
811 __set_current_state(TASK_INTERRUPTIBLE); 811 __set_current_state(TASK_INTERRUPTIBLE);
812 add_wait_queue(&nlk->wait, &wait); 812 add_wait_queue(&nlk->wait, &wait);
813 813
814 if ((atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf || 814 if ((atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
815 test_bit(0, &nlk->state)) && 815 test_bit(0, &nlk->state)) &&
816 !sock_flag(sk, SOCK_DEAD)) 816 !sock_flag(sk, SOCK_DEAD))
817 *timeo = schedule_timeout(*timeo); 817 *timeo = schedule_timeout(*timeo);
818 818
819 __set_current_state(TASK_RUNNING); 819 __set_current_state(TASK_RUNNING);
820 remove_wait_queue(&nlk->wait, &wait); 820 remove_wait_queue(&nlk->wait, &wait);
821 sock_put(sk); 821 sock_put(sk);
822 822
823 if (signal_pending(current)) { 823 if (signal_pending(current)) {
824 kfree_skb(skb); 824 kfree_skb(skb);
825 return sock_intr_errno(*timeo); 825 return sock_intr_errno(*timeo);
826 } 826 }
827 return 1; 827 return 1;
828 } 828 }
829 skb_set_owner_r(skb, sk); 829 skb_set_owner_r(skb, sk);
830 return 0; 830 return 0;
831 } 831 }
832 832
833 int netlink_sendskb(struct sock *sk, struct sk_buff *skb) 833 int netlink_sendskb(struct sock *sk, struct sk_buff *skb)
834 { 834 {
835 int len = skb->len; 835 int len = skb->len;
836 836
837 skb_queue_tail(&sk->sk_receive_queue, skb); 837 skb_queue_tail(&sk->sk_receive_queue, skb);
838 sk->sk_data_ready(sk, len); 838 sk->sk_data_ready(sk, len);
839 sock_put(sk); 839 sock_put(sk);
840 return len; 840 return len;
841 } 841 }
842 842
843 void netlink_detachskb(struct sock *sk, struct sk_buff *skb) 843 void netlink_detachskb(struct sock *sk, struct sk_buff *skb)
844 { 844 {
845 kfree_skb(skb); 845 kfree_skb(skb);
846 sock_put(sk); 846 sock_put(sk);
847 } 847 }
848 848
849 static inline struct sk_buff *netlink_trim(struct sk_buff *skb, 849 static inline struct sk_buff *netlink_trim(struct sk_buff *skb,
850 gfp_t allocation) 850 gfp_t allocation)
851 { 851 {
852 int delta; 852 int delta;
853 853
854 skb_orphan(skb); 854 skb_orphan(skb);
855 855
856 delta = skb->end - skb->tail; 856 delta = skb->end - skb->tail;
857 if (delta * 2 < skb->truesize) 857 if (delta * 2 < skb->truesize)
858 return skb; 858 return skb;
859 859
860 if (skb_shared(skb)) { 860 if (skb_shared(skb)) {
861 struct sk_buff *nskb = skb_clone(skb, allocation); 861 struct sk_buff *nskb = skb_clone(skb, allocation);
862 if (!nskb) 862 if (!nskb)
863 return skb; 863 return skb;
864 kfree_skb(skb); 864 kfree_skb(skb);
865 skb = nskb; 865 skb = nskb;
866 } 866 }
867 867
868 if (!pskb_expand_head(skb, 0, -delta, allocation)) 868 if (!pskb_expand_head(skb, 0, -delta, allocation))
869 skb->truesize -= delta; 869 skb->truesize -= delta;
870 870
871 return skb; 871 return skb;
872 } 872 }
873 873
874 static inline void netlink_rcv_wake(struct sock *sk) 874 static inline void netlink_rcv_wake(struct sock *sk)
875 { 875 {
876 struct netlink_sock *nlk = nlk_sk(sk); 876 struct netlink_sock *nlk = nlk_sk(sk);
877 877
878 if (skb_queue_empty(&sk->sk_receive_queue)) 878 if (skb_queue_empty(&sk->sk_receive_queue))
879 clear_bit(0, &nlk->state); 879 clear_bit(0, &nlk->state);
880 if (!test_bit(0, &nlk->state)) 880 if (!test_bit(0, &nlk->state))
881 wake_up_interruptible(&nlk->wait); 881 wake_up_interruptible(&nlk->wait);
882 } 882 }
883 883
884 static inline int netlink_unicast_kernel(struct sock *sk, struct sk_buff *skb) 884 static inline int netlink_unicast_kernel(struct sock *sk, struct sk_buff *skb)
885 { 885 {
886 int ret; 886 int ret;
887 struct netlink_sock *nlk = nlk_sk(sk); 887 struct netlink_sock *nlk = nlk_sk(sk);
888 888
889 ret = -ECONNREFUSED; 889 ret = -ECONNREFUSED;
890 if (nlk->netlink_rcv != NULL) { 890 if (nlk->netlink_rcv != NULL) {
891 ret = skb->len; 891 ret = skb->len;
892 skb_set_owner_r(skb, sk); 892 skb_set_owner_r(skb, sk);
893 nlk->netlink_rcv(skb); 893 nlk->netlink_rcv(skb);
894 } 894 }
895 kfree_skb(skb); 895 kfree_skb(skb);
896 sock_put(sk); 896 sock_put(sk);
897 return ret; 897 return ret;
898 } 898 }
899 899
900 int netlink_unicast(struct sock *ssk, struct sk_buff *skb, 900 int netlink_unicast(struct sock *ssk, struct sk_buff *skb,
901 u32 pid, int nonblock) 901 u32 pid, int nonblock)
902 { 902 {
903 struct sock *sk; 903 struct sock *sk;
904 int err; 904 int err;
905 long timeo; 905 long timeo;
906 906
907 skb = netlink_trim(skb, gfp_any()); 907 skb = netlink_trim(skb, gfp_any());
908 908
909 timeo = sock_sndtimeo(ssk, nonblock); 909 timeo = sock_sndtimeo(ssk, nonblock);
910 retry: 910 retry:
911 sk = netlink_getsockbypid(ssk, pid); 911 sk = netlink_getsockbypid(ssk, pid);
912 if (IS_ERR(sk)) { 912 if (IS_ERR(sk)) {
913 kfree_skb(skb); 913 kfree_skb(skb);
914 return PTR_ERR(sk); 914 return PTR_ERR(sk);
915 } 915 }
916 if (netlink_is_kernel(sk)) 916 if (netlink_is_kernel(sk))
917 return netlink_unicast_kernel(sk, skb); 917 return netlink_unicast_kernel(sk, skb);
918 918
919 if (sk_filter(sk, skb)) { 919 if (sk_filter(sk, skb)) {
920 err = skb->len; 920 err = skb->len;
921 kfree_skb(skb); 921 kfree_skb(skb);
922 sock_put(sk); 922 sock_put(sk);
923 return err; 923 return err;
924 } 924 }
925 925
926 err = netlink_attachskb(sk, skb, &timeo, ssk); 926 err = netlink_attachskb(sk, skb, &timeo, ssk);
927 if (err == 1) 927 if (err == 1)
928 goto retry; 928 goto retry;
929 if (err) 929 if (err)
930 return err; 930 return err;
931 931
932 return netlink_sendskb(sk, skb); 932 return netlink_sendskb(sk, skb);
933 } 933 }
934 EXPORT_SYMBOL(netlink_unicast); 934 EXPORT_SYMBOL(netlink_unicast);
935 935
936 int netlink_has_listeners(struct sock *sk, unsigned int group) 936 int netlink_has_listeners(struct sock *sk, unsigned int group)
937 { 937 {
938 int res = 0; 938 int res = 0;
939 struct listeners *listeners; 939 struct listeners *listeners;
940 940
941 BUG_ON(!netlink_is_kernel(sk)); 941 BUG_ON(!netlink_is_kernel(sk));
942 942
943 rcu_read_lock(); 943 rcu_read_lock();
944 listeners = rcu_dereference(nl_table[sk->sk_protocol].listeners); 944 listeners = rcu_dereference(nl_table[sk->sk_protocol].listeners);
945 945
946 if (group - 1 < nl_table[sk->sk_protocol].groups) 946 if (group - 1 < nl_table[sk->sk_protocol].groups)
947 res = test_bit(group - 1, listeners->masks); 947 res = test_bit(group - 1, listeners->masks);
948 948
949 rcu_read_unlock(); 949 rcu_read_unlock();
950 950
951 return res; 951 return res;
952 } 952 }
953 EXPORT_SYMBOL_GPL(netlink_has_listeners); 953 EXPORT_SYMBOL_GPL(netlink_has_listeners);
954 954
955 static inline int netlink_broadcast_deliver(struct sock *sk, 955 static inline int netlink_broadcast_deliver(struct sock *sk,
956 struct sk_buff *skb) 956 struct sk_buff *skb)
957 { 957 {
958 struct netlink_sock *nlk = nlk_sk(sk); 958 struct netlink_sock *nlk = nlk_sk(sk);
959 959
960 if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf && 960 if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf &&
961 !test_bit(0, &nlk->state)) { 961 !test_bit(0, &nlk->state)) {
962 skb_set_owner_r(skb, sk); 962 skb_set_owner_r(skb, sk);
963 skb_queue_tail(&sk->sk_receive_queue, skb); 963 skb_queue_tail(&sk->sk_receive_queue, skb);
964 sk->sk_data_ready(sk, skb->len); 964 sk->sk_data_ready(sk, skb->len);
965 return atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf; 965 return atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf;
966 } 966 }
967 return -1; 967 return -1;
968 } 968 }
969 969
970 struct netlink_broadcast_data { 970 struct netlink_broadcast_data {
971 struct sock *exclude_sk; 971 struct sock *exclude_sk;
972 struct net *net; 972 struct net *net;
973 u32 pid; 973 u32 pid;
974 u32 group; 974 u32 group;
975 int failure; 975 int failure;
976 int delivery_failure; 976 int delivery_failure;
977 int congested; 977 int congested;
978 int delivered; 978 int delivered;
979 gfp_t allocation; 979 gfp_t allocation;
980 struct sk_buff *skb, *skb2; 980 struct sk_buff *skb, *skb2;
981 int (*tx_filter)(struct sock *dsk, struct sk_buff *skb, void *data); 981 int (*tx_filter)(struct sock *dsk, struct sk_buff *skb, void *data);
982 void *tx_data; 982 void *tx_data;
983 }; 983 };
984 984
985 static inline int do_one_broadcast(struct sock *sk, 985 static inline int do_one_broadcast(struct sock *sk,
986 struct netlink_broadcast_data *p) 986 struct netlink_broadcast_data *p)
987 { 987 {
988 struct netlink_sock *nlk = nlk_sk(sk); 988 struct netlink_sock *nlk = nlk_sk(sk);
989 int val; 989 int val;
990 990
991 if (p->exclude_sk == sk) 991 if (p->exclude_sk == sk)
992 goto out; 992 goto out;
993 993
994 if (nlk->pid == p->pid || p->group - 1 >= nlk->ngroups || 994 if (nlk->pid == p->pid || p->group - 1 >= nlk->ngroups ||
995 !test_bit(p->group - 1, nlk->groups)) 995 !test_bit(p->group - 1, nlk->groups))
996 goto out; 996 goto out;
997 997
998 if (!net_eq(sock_net(sk), p->net)) 998 if (!net_eq(sock_net(sk), p->net))
999 goto out; 999 goto out;
1000 1000
1001 if (p->failure) { 1001 if (p->failure) {
1002 netlink_overrun(sk); 1002 netlink_overrun(sk);
1003 goto out; 1003 goto out;
1004 } 1004 }
1005 1005
1006 sock_hold(sk); 1006 sock_hold(sk);
1007 if (p->skb2 == NULL) { 1007 if (p->skb2 == NULL) {
1008 if (skb_shared(p->skb)) { 1008 if (skb_shared(p->skb)) {
1009 p->skb2 = skb_clone(p->skb, p->allocation); 1009 p->skb2 = skb_clone(p->skb, p->allocation);
1010 } else { 1010 } else {
1011 p->skb2 = skb_get(p->skb); 1011 p->skb2 = skb_get(p->skb);
1012 /* 1012 /*
1013 * skb ownership may have been set when 1013 * skb ownership may have been set when
1014 * delivered to a previous socket. 1014 * delivered to a previous socket.
1015 */ 1015 */
1016 skb_orphan(p->skb2); 1016 skb_orphan(p->skb2);
1017 } 1017 }
1018 } 1018 }
1019 if (p->skb2 == NULL) { 1019 if (p->skb2 == NULL) {
1020 netlink_overrun(sk); 1020 netlink_overrun(sk);
1021 /* Clone failed. Notify ALL listeners. */ 1021 /* Clone failed. Notify ALL listeners. */
1022 p->failure = 1; 1022 p->failure = 1;
1023 if (nlk->flags & NETLINK_BROADCAST_SEND_ERROR) 1023 if (nlk->flags & NETLINK_BROADCAST_SEND_ERROR)
1024 p->delivery_failure = 1; 1024 p->delivery_failure = 1;
1025 } else if (p->tx_filter && p->tx_filter(sk, p->skb2, p->tx_data)) { 1025 } else if (p->tx_filter && p->tx_filter(sk, p->skb2, p->tx_data)) {
1026 kfree_skb(p->skb2); 1026 kfree_skb(p->skb2);
1027 p->skb2 = NULL; 1027 p->skb2 = NULL;
1028 } else if (sk_filter(sk, p->skb2)) { 1028 } else if (sk_filter(sk, p->skb2)) {
1029 kfree_skb(p->skb2); 1029 kfree_skb(p->skb2);
1030 p->skb2 = NULL; 1030 p->skb2 = NULL;
1031 } else if ((val = netlink_broadcast_deliver(sk, p->skb2)) < 0) { 1031 } else if ((val = netlink_broadcast_deliver(sk, p->skb2)) < 0) {
1032 netlink_overrun(sk); 1032 netlink_overrun(sk);
1033 if (nlk->flags & NETLINK_BROADCAST_SEND_ERROR) 1033 if (nlk->flags & NETLINK_BROADCAST_SEND_ERROR)
1034 p->delivery_failure = 1; 1034 p->delivery_failure = 1;
1035 } else { 1035 } else {
1036 p->congested |= val; 1036 p->congested |= val;
1037 p->delivered = 1; 1037 p->delivered = 1;
1038 p->skb2 = NULL; 1038 p->skb2 = NULL;
1039 } 1039 }
1040 sock_put(sk); 1040 sock_put(sk);
1041 1041
1042 out: 1042 out:
1043 return 0; 1043 return 0;
1044 } 1044 }
1045 1045
1046 int netlink_broadcast_filtered(struct sock *ssk, struct sk_buff *skb, u32 pid, 1046 int netlink_broadcast_filtered(struct sock *ssk, struct sk_buff *skb, u32 pid,
1047 u32 group, gfp_t allocation, 1047 u32 group, gfp_t allocation,
1048 int (*filter)(struct sock *dsk, struct sk_buff *skb, void *data), 1048 int (*filter)(struct sock *dsk, struct sk_buff *skb, void *data),
1049 void *filter_data) 1049 void *filter_data)
1050 { 1050 {
1051 struct net *net = sock_net(ssk); 1051 struct net *net = sock_net(ssk);
1052 struct netlink_broadcast_data info; 1052 struct netlink_broadcast_data info;
1053 struct hlist_node *node; 1053 struct hlist_node *node;
1054 struct sock *sk; 1054 struct sock *sk;
1055 1055
1056 skb = netlink_trim(skb, allocation); 1056 skb = netlink_trim(skb, allocation);
1057 1057
1058 info.exclude_sk = ssk; 1058 info.exclude_sk = ssk;
1059 info.net = net; 1059 info.net = net;
1060 info.pid = pid; 1060 info.pid = pid;
1061 info.group = group; 1061 info.group = group;
1062 info.failure = 0; 1062 info.failure = 0;
1063 info.delivery_failure = 0; 1063 info.delivery_failure = 0;
1064 info.congested = 0; 1064 info.congested = 0;
1065 info.delivered = 0; 1065 info.delivered = 0;
1066 info.allocation = allocation; 1066 info.allocation = allocation;
1067 info.skb = skb; 1067 info.skb = skb;
1068 info.skb2 = NULL; 1068 info.skb2 = NULL;
1069 info.tx_filter = filter; 1069 info.tx_filter = filter;
1070 info.tx_data = filter_data; 1070 info.tx_data = filter_data;
1071 1071
1072 /* While we sleep in clone, do not allow to change socket list */ 1072 /* While we sleep in clone, do not allow to change socket list */
1073 1073
1074 netlink_lock_table(); 1074 netlink_lock_table();
1075 1075
1076 sk_for_each_bound(sk, node, &nl_table[ssk->sk_protocol].mc_list) 1076 sk_for_each_bound(sk, node, &nl_table[ssk->sk_protocol].mc_list)
1077 do_one_broadcast(sk, &info); 1077 do_one_broadcast(sk, &info);
1078 1078
1079 consume_skb(skb); 1079 consume_skb(skb);
1080 1080
1081 netlink_unlock_table(); 1081 netlink_unlock_table();
1082 1082
1083 if (info.delivery_failure) { 1083 if (info.delivery_failure) {
1084 kfree_skb(info.skb2); 1084 kfree_skb(info.skb2);
1085 return -ENOBUFS; 1085 return -ENOBUFS;
1086 } else 1086 } else
1087 consume_skb(info.skb2); 1087 consume_skb(info.skb2);
1088 1088
1089 if (info.delivered) { 1089 if (info.delivered) {
1090 if (info.congested && (allocation & __GFP_WAIT)) 1090 if (info.congested && (allocation & __GFP_WAIT))
1091 yield(); 1091 yield();
1092 return 0; 1092 return 0;
1093 } 1093 }
1094 return -ESRCH; 1094 return -ESRCH;
1095 } 1095 }
1096 EXPORT_SYMBOL(netlink_broadcast_filtered); 1096 EXPORT_SYMBOL(netlink_broadcast_filtered);
1097 1097
1098 int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, u32 pid, 1098 int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, u32 pid,
1099 u32 group, gfp_t allocation) 1099 u32 group, gfp_t allocation)
1100 { 1100 {
1101 return netlink_broadcast_filtered(ssk, skb, pid, group, allocation, 1101 return netlink_broadcast_filtered(ssk, skb, pid, group, allocation,
1102 NULL, NULL); 1102 NULL, NULL);
1103 } 1103 }
1104 EXPORT_SYMBOL(netlink_broadcast); 1104 EXPORT_SYMBOL(netlink_broadcast);
1105 1105
1106 struct netlink_set_err_data { 1106 struct netlink_set_err_data {
1107 struct sock *exclude_sk; 1107 struct sock *exclude_sk;
1108 u32 pid; 1108 u32 pid;
1109 u32 group; 1109 u32 group;
1110 int code; 1110 int code;
1111 }; 1111 };
1112 1112
1113 static inline int do_one_set_err(struct sock *sk, 1113 static inline int do_one_set_err(struct sock *sk,
1114 struct netlink_set_err_data *p) 1114 struct netlink_set_err_data *p)
1115 { 1115 {
1116 struct netlink_sock *nlk = nlk_sk(sk); 1116 struct netlink_sock *nlk = nlk_sk(sk);
1117 int ret = 0; 1117 int ret = 0;
1118 1118
1119 if (sk == p->exclude_sk) 1119 if (sk == p->exclude_sk)
1120 goto out; 1120 goto out;
1121 1121
1122 if (!net_eq(sock_net(sk), sock_net(p->exclude_sk))) 1122 if (!net_eq(sock_net(sk), sock_net(p->exclude_sk)))
1123 goto out; 1123 goto out;
1124 1124
1125 if (nlk->pid == p->pid || p->group - 1 >= nlk->ngroups || 1125 if (nlk->pid == p->pid || p->group - 1 >= nlk->ngroups ||
1126 !test_bit(p->group - 1, nlk->groups)) 1126 !test_bit(p->group - 1, nlk->groups))
1127 goto out; 1127 goto out;
1128 1128
1129 if (p->code == ENOBUFS && nlk->flags & NETLINK_RECV_NO_ENOBUFS) { 1129 if (p->code == ENOBUFS && nlk->flags & NETLINK_RECV_NO_ENOBUFS) {
1130 ret = 1; 1130 ret = 1;
1131 goto out; 1131 goto out;
1132 } 1132 }
1133 1133
1134 sk->sk_err = p->code; 1134 sk->sk_err = p->code;
1135 sk->sk_error_report(sk); 1135 sk->sk_error_report(sk);
1136 out: 1136 out:
1137 return ret; 1137 return ret;
1138 } 1138 }
1139 1139
1140 /** 1140 /**
1141 * netlink_set_err - report error to broadcast listeners 1141 * netlink_set_err - report error to broadcast listeners
1142 * @ssk: the kernel netlink socket, as returned by netlink_kernel_create() 1142 * @ssk: the kernel netlink socket, as returned by netlink_kernel_create()
1143 * @pid: the PID of a process that we want to skip (if any) 1143 * @pid: the PID of a process that we want to skip (if any)
1144 * @groups: the broadcast group that will notice the error 1144 * @groups: the broadcast group that will notice the error
1145 * @code: error code, must be negative (as usual in kernelspace) 1145 * @code: error code, must be negative (as usual in kernelspace)
1146 * 1146 *
1147 * This function returns the number of broadcast listeners that have set the 1147 * This function returns the number of broadcast listeners that have set the
1148 * NETLINK_RECV_NO_ENOBUFS socket option. 1148 * NETLINK_RECV_NO_ENOBUFS socket option.
1149 */ 1149 */
1150 int netlink_set_err(struct sock *ssk, u32 pid, u32 group, int code) 1150 int netlink_set_err(struct sock *ssk, u32 pid, u32 group, int code)
1151 { 1151 {
1152 struct netlink_set_err_data info; 1152 struct netlink_set_err_data info;
1153 struct hlist_node *node; 1153 struct hlist_node *node;
1154 struct sock *sk; 1154 struct sock *sk;
1155 int ret = 0; 1155 int ret = 0;
1156 1156
1157 info.exclude_sk = ssk; 1157 info.exclude_sk = ssk;
1158 info.pid = pid; 1158 info.pid = pid;
1159 info.group = group; 1159 info.group = group;
1160 /* sk->sk_err wants a positive error value */ 1160 /* sk->sk_err wants a positive error value */
1161 info.code = -code; 1161 info.code = -code;
1162 1162
1163 read_lock(&nl_table_lock); 1163 read_lock(&nl_table_lock);
1164 1164
1165 sk_for_each_bound(sk, node, &nl_table[ssk->sk_protocol].mc_list) 1165 sk_for_each_bound(sk, node, &nl_table[ssk->sk_protocol].mc_list)
1166 ret += do_one_set_err(sk, &info); 1166 ret += do_one_set_err(sk, &info);
1167 1167
1168 read_unlock(&nl_table_lock); 1168 read_unlock(&nl_table_lock);
1169 return ret; 1169 return ret;
1170 } 1170 }
1171 EXPORT_SYMBOL(netlink_set_err); 1171 EXPORT_SYMBOL(netlink_set_err);
1172 1172
1173 /* must be called with netlink table grabbed */ 1173 /* must be called with netlink table grabbed */
1174 static void netlink_update_socket_mc(struct netlink_sock *nlk, 1174 static void netlink_update_socket_mc(struct netlink_sock *nlk,
1175 unsigned int group, 1175 unsigned int group,
1176 int is_new) 1176 int is_new)
1177 { 1177 {
1178 int old, new = !!is_new, subscriptions; 1178 int old, new = !!is_new, subscriptions;
1179 1179
1180 old = test_bit(group - 1, nlk->groups); 1180 old = test_bit(group - 1, nlk->groups);
1181 subscriptions = nlk->subscriptions - old + new; 1181 subscriptions = nlk->subscriptions - old + new;
1182 if (new) 1182 if (new)
1183 __set_bit(group - 1, nlk->groups); 1183 __set_bit(group - 1, nlk->groups);
1184 else 1184 else
1185 __clear_bit(group - 1, nlk->groups); 1185 __clear_bit(group - 1, nlk->groups);
1186 netlink_update_subscriptions(&nlk->sk, subscriptions); 1186 netlink_update_subscriptions(&nlk->sk, subscriptions);
1187 netlink_update_listeners(&nlk->sk); 1187 netlink_update_listeners(&nlk->sk);
1188 } 1188 }
1189 1189
1190 static int netlink_setsockopt(struct socket *sock, int level, int optname, 1190 static int netlink_setsockopt(struct socket *sock, int level, int optname,
1191 char __user *optval, unsigned int optlen) 1191 char __user *optval, unsigned int optlen)
1192 { 1192 {
1193 struct sock *sk = sock->sk; 1193 struct sock *sk = sock->sk;
1194 struct netlink_sock *nlk = nlk_sk(sk); 1194 struct netlink_sock *nlk = nlk_sk(sk);
1195 unsigned int val = 0; 1195 unsigned int val = 0;
1196 int err; 1196 int err;
1197 1197
1198 if (level != SOL_NETLINK) 1198 if (level != SOL_NETLINK)
1199 return -ENOPROTOOPT; 1199 return -ENOPROTOOPT;
1200 1200
1201 if (optlen >= sizeof(int) && 1201 if (optlen >= sizeof(int) &&
1202 get_user(val, (unsigned int __user *)optval)) 1202 get_user(val, (unsigned int __user *)optval))
1203 return -EFAULT; 1203 return -EFAULT;
1204 1204
1205 switch (optname) { 1205 switch (optname) {
1206 case NETLINK_PKTINFO: 1206 case NETLINK_PKTINFO:
1207 if (val) 1207 if (val)
1208 nlk->flags |= NETLINK_RECV_PKTINFO; 1208 nlk->flags |= NETLINK_RECV_PKTINFO;
1209 else 1209 else
1210 nlk->flags &= ~NETLINK_RECV_PKTINFO; 1210 nlk->flags &= ~NETLINK_RECV_PKTINFO;
1211 err = 0; 1211 err = 0;
1212 break; 1212 break;
1213 case NETLINK_ADD_MEMBERSHIP: 1213 case NETLINK_ADD_MEMBERSHIP:
1214 case NETLINK_DROP_MEMBERSHIP: { 1214 case NETLINK_DROP_MEMBERSHIP: {
1215 if (!netlink_capable(sock, NL_NONROOT_RECV)) 1215 if (!netlink_capable(sock, NL_NONROOT_RECV))
1216 return -EPERM; 1216 return -EPERM;
1217 err = netlink_realloc_groups(sk); 1217 err = netlink_realloc_groups(sk);
1218 if (err) 1218 if (err)
1219 return err; 1219 return err;
1220 if (!val || val - 1 >= nlk->ngroups) 1220 if (!val || val - 1 >= nlk->ngroups)
1221 return -EINVAL; 1221 return -EINVAL;
1222 netlink_table_grab(); 1222 netlink_table_grab();
1223 netlink_update_socket_mc(nlk, val, 1223 netlink_update_socket_mc(nlk, val,
1224 optname == NETLINK_ADD_MEMBERSHIP); 1224 optname == NETLINK_ADD_MEMBERSHIP);
1225 netlink_table_ungrab(); 1225 netlink_table_ungrab();
1226 err = 0; 1226 err = 0;
1227 break; 1227 break;
1228 } 1228 }
1229 case NETLINK_BROADCAST_ERROR: 1229 case NETLINK_BROADCAST_ERROR:
1230 if (val) 1230 if (val)
1231 nlk->flags |= NETLINK_BROADCAST_SEND_ERROR; 1231 nlk->flags |= NETLINK_BROADCAST_SEND_ERROR;
1232 else 1232 else
1233 nlk->flags &= ~NETLINK_BROADCAST_SEND_ERROR; 1233 nlk->flags &= ~NETLINK_BROADCAST_SEND_ERROR;
1234 err = 0; 1234 err = 0;
1235 break; 1235 break;
1236 case NETLINK_NO_ENOBUFS: 1236 case NETLINK_NO_ENOBUFS:
1237 if (val) { 1237 if (val) {
1238 nlk->flags |= NETLINK_RECV_NO_ENOBUFS; 1238 nlk->flags |= NETLINK_RECV_NO_ENOBUFS;
1239 clear_bit(0, &nlk->state); 1239 clear_bit(0, &nlk->state);
1240 wake_up_interruptible(&nlk->wait); 1240 wake_up_interruptible(&nlk->wait);
1241 } else 1241 } else
1242 nlk->flags &= ~NETLINK_RECV_NO_ENOBUFS; 1242 nlk->flags &= ~NETLINK_RECV_NO_ENOBUFS;
1243 err = 0; 1243 err = 0;
1244 break; 1244 break;
1245 default: 1245 default:
1246 err = -ENOPROTOOPT; 1246 err = -ENOPROTOOPT;
1247 } 1247 }
1248 return err; 1248 return err;
1249 } 1249 }
1250 1250
1251 static int netlink_getsockopt(struct socket *sock, int level, int optname, 1251 static int netlink_getsockopt(struct socket *sock, int level, int optname,
1252 char __user *optval, int __user *optlen) 1252 char __user *optval, int __user *optlen)
1253 { 1253 {
1254 struct sock *sk = sock->sk; 1254 struct sock *sk = sock->sk;
1255 struct netlink_sock *nlk = nlk_sk(sk); 1255 struct netlink_sock *nlk = nlk_sk(sk);
1256 int len, val, err; 1256 int len, val, err;
1257 1257
1258 if (level != SOL_NETLINK) 1258 if (level != SOL_NETLINK)
1259 return -ENOPROTOOPT; 1259 return -ENOPROTOOPT;
1260 1260
1261 if (get_user(len, optlen)) 1261 if (get_user(len, optlen))
1262 return -EFAULT; 1262 return -EFAULT;
1263 if (len < 0) 1263 if (len < 0)
1264 return -EINVAL; 1264 return -EINVAL;
1265 1265
1266 switch (optname) { 1266 switch (optname) {
1267 case NETLINK_PKTINFO: 1267 case NETLINK_PKTINFO:
1268 if (len < sizeof(int)) 1268 if (len < sizeof(int))
1269 return -EINVAL; 1269 return -EINVAL;
1270 len = sizeof(int); 1270 len = sizeof(int);
1271 val = nlk->flags & NETLINK_RECV_PKTINFO ? 1 : 0; 1271 val = nlk->flags & NETLINK_RECV_PKTINFO ? 1 : 0;
1272 if (put_user(len, optlen) || 1272 if (put_user(len, optlen) ||
1273 put_user(val, optval)) 1273 put_user(val, optval))
1274 return -EFAULT; 1274 return -EFAULT;
1275 err = 0; 1275 err = 0;
1276 break; 1276 break;
1277 case NETLINK_BROADCAST_ERROR: 1277 case NETLINK_BROADCAST_ERROR:
1278 if (len < sizeof(int)) 1278 if (len < sizeof(int))
1279 return -EINVAL; 1279 return -EINVAL;
1280 len = sizeof(int); 1280 len = sizeof(int);
1281 val = nlk->flags & NETLINK_BROADCAST_SEND_ERROR ? 1 : 0; 1281 val = nlk->flags & NETLINK_BROADCAST_SEND_ERROR ? 1 : 0;
1282 if (put_user(len, optlen) || 1282 if (put_user(len, optlen) ||
1283 put_user(val, optval)) 1283 put_user(val, optval))
1284 return -EFAULT; 1284 return -EFAULT;
1285 err = 0; 1285 err = 0;
1286 break; 1286 break;
1287 case NETLINK_NO_ENOBUFS: 1287 case NETLINK_NO_ENOBUFS:
1288 if (len < sizeof(int)) 1288 if (len < sizeof(int))
1289 return -EINVAL; 1289 return -EINVAL;
1290 len = sizeof(int); 1290 len = sizeof(int);
1291 val = nlk->flags & NETLINK_RECV_NO_ENOBUFS ? 1 : 0; 1291 val = nlk->flags & NETLINK_RECV_NO_ENOBUFS ? 1 : 0;
1292 if (put_user(len, optlen) || 1292 if (put_user(len, optlen) ||
1293 put_user(val, optval)) 1293 put_user(val, optval))
1294 return -EFAULT; 1294 return -EFAULT;
1295 err = 0; 1295 err = 0;
1296 break; 1296 break;
1297 default: 1297 default:
1298 err = -ENOPROTOOPT; 1298 err = -ENOPROTOOPT;
1299 } 1299 }
1300 return err; 1300 return err;
1301 } 1301 }
1302 1302
1303 static void netlink_cmsg_recv_pktinfo(struct msghdr *msg, struct sk_buff *skb) 1303 static void netlink_cmsg_recv_pktinfo(struct msghdr *msg, struct sk_buff *skb)
1304 { 1304 {
1305 struct nl_pktinfo info; 1305 struct nl_pktinfo info;
1306 1306
1307 info.group = NETLINK_CB(skb).dst_group; 1307 info.group = NETLINK_CB(skb).dst_group;
1308 put_cmsg(msg, SOL_NETLINK, NETLINK_PKTINFO, sizeof(info), &info); 1308 put_cmsg(msg, SOL_NETLINK, NETLINK_PKTINFO, sizeof(info), &info);
1309 } 1309 }
1310 1310
1311 static int netlink_sendmsg(struct kiocb *kiocb, struct socket *sock, 1311 static int netlink_sendmsg(struct kiocb *kiocb, struct socket *sock,
1312 struct msghdr *msg, size_t len) 1312 struct msghdr *msg, size_t len)
1313 { 1313 {
1314 struct sock_iocb *siocb = kiocb_to_siocb(kiocb); 1314 struct sock_iocb *siocb = kiocb_to_siocb(kiocb);
1315 struct sock *sk = sock->sk; 1315 struct sock *sk = sock->sk;
1316 struct netlink_sock *nlk = nlk_sk(sk); 1316 struct netlink_sock *nlk = nlk_sk(sk);
1317 struct sockaddr_nl *addr = msg->msg_name; 1317 struct sockaddr_nl *addr = msg->msg_name;
1318 u32 dst_pid; 1318 u32 dst_pid;
1319 u32 dst_group; 1319 u32 dst_group;
1320 struct sk_buff *skb; 1320 struct sk_buff *skb;
1321 int err; 1321 int err;
1322 struct scm_cookie scm; 1322 struct scm_cookie scm;
1323 1323
1324 if (msg->msg_flags&MSG_OOB) 1324 if (msg->msg_flags&MSG_OOB)
1325 return -EOPNOTSUPP; 1325 return -EOPNOTSUPP;
1326 1326
1327 if (NULL == siocb->scm) { 1327 if (NULL == siocb->scm) {
1328 siocb->scm = &scm; 1328 siocb->scm = &scm;
1329 memset(&scm, 0, sizeof(scm)); 1329 memset(&scm, 0, sizeof(scm));
1330 } 1330 }
1331 err = scm_send(sock, msg, siocb->scm); 1331 err = scm_send(sock, msg, siocb->scm);
1332 if (err < 0) 1332 if (err < 0)
1333 return err; 1333 return err;
1334 1334
1335 if (msg->msg_namelen) { 1335 if (msg->msg_namelen) {
1336 err = -EINVAL; 1336 err = -EINVAL;
1337 if (addr->nl_family != AF_NETLINK) 1337 if (addr->nl_family != AF_NETLINK)
1338 goto out; 1338 goto out;
1339 dst_pid = addr->nl_pid; 1339 dst_pid = addr->nl_pid;
1340 dst_group = ffs(addr->nl_groups); 1340 dst_group = ffs(addr->nl_groups);
1341 err = -EPERM; 1341 err = -EPERM;
1342 if (dst_group && !netlink_capable(sock, NL_NONROOT_SEND)) 1342 if (dst_group && !netlink_capable(sock, NL_NONROOT_SEND))
1343 goto out; 1343 goto out;
1344 } else { 1344 } else {
1345 dst_pid = nlk->dst_pid; 1345 dst_pid = nlk->dst_pid;
1346 dst_group = nlk->dst_group; 1346 dst_group = nlk->dst_group;
1347 } 1347 }
1348 1348
1349 if (!nlk->pid) { 1349 if (!nlk->pid) {
1350 err = netlink_autobind(sock); 1350 err = netlink_autobind(sock);
1351 if (err) 1351 if (err)
1352 goto out; 1352 goto out;
1353 } 1353 }
1354 1354
1355 err = -EMSGSIZE; 1355 err = -EMSGSIZE;
1356 if (len > sk->sk_sndbuf - 32) 1356 if (len > sk->sk_sndbuf - 32)
1357 goto out; 1357 goto out;
1358 err = -ENOBUFS; 1358 err = -ENOBUFS;
1359 skb = alloc_skb(len, GFP_KERNEL); 1359 skb = alloc_skb(len, GFP_KERNEL);
1360 if (skb == NULL) 1360 if (skb == NULL)
1361 goto out; 1361 goto out;
1362 1362
1363 NETLINK_CB(skb).pid = nlk->pid; 1363 NETLINK_CB(skb).pid = nlk->pid;
1364 NETLINK_CB(skb).dst_group = dst_group; 1364 NETLINK_CB(skb).dst_group = dst_group;
1365 memcpy(NETLINK_CREDS(skb), &siocb->scm->creds, sizeof(struct ucred)); 1365 memcpy(NETLINK_CREDS(skb), &siocb->scm->creds, sizeof(struct ucred));
1366 1366
1367 err = -EFAULT; 1367 err = -EFAULT;
1368 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) { 1368 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
1369 kfree_skb(skb); 1369 kfree_skb(skb);
1370 goto out; 1370 goto out;
1371 } 1371 }
1372 1372
1373 err = security_netlink_send(sk, skb); 1373 err = security_netlink_send(sk, skb);
1374 if (err) { 1374 if (err) {
1375 kfree_skb(skb); 1375 kfree_skb(skb);
1376 goto out; 1376 goto out;
1377 } 1377 }
1378 1378
1379 if (dst_group) { 1379 if (dst_group) {
1380 atomic_inc(&skb->users); 1380 atomic_inc(&skb->users);
1381 netlink_broadcast(sk, skb, dst_pid, dst_group, GFP_KERNEL); 1381 netlink_broadcast(sk, skb, dst_pid, dst_group, GFP_KERNEL);
1382 } 1382 }
1383 err = netlink_unicast(sk, skb, dst_pid, msg->msg_flags&MSG_DONTWAIT); 1383 err = netlink_unicast(sk, skb, dst_pid, msg->msg_flags&MSG_DONTWAIT);
1384 1384
1385 out: 1385 out:
1386 scm_destroy(siocb->scm); 1386 scm_destroy(siocb->scm);
1387 return err; 1387 return err;
1388 } 1388 }
1389 1389
1390 static int netlink_recvmsg(struct kiocb *kiocb, struct socket *sock, 1390 static int netlink_recvmsg(struct kiocb *kiocb, struct socket *sock,
1391 struct msghdr *msg, size_t len, 1391 struct msghdr *msg, size_t len,
1392 int flags) 1392 int flags)
1393 { 1393 {
1394 struct sock_iocb *siocb = kiocb_to_siocb(kiocb); 1394 struct sock_iocb *siocb = kiocb_to_siocb(kiocb);
1395 struct scm_cookie scm; 1395 struct scm_cookie scm;
1396 struct sock *sk = sock->sk; 1396 struct sock *sk = sock->sk;
1397 struct netlink_sock *nlk = nlk_sk(sk); 1397 struct netlink_sock *nlk = nlk_sk(sk);
1398 int noblock = flags&MSG_DONTWAIT; 1398 int noblock = flags&MSG_DONTWAIT;
1399 size_t copied; 1399 size_t copied;
1400 struct sk_buff *skb, *data_skb; 1400 struct sk_buff *skb, *data_skb;
1401 int err, ret; 1401 int err, ret;
1402 1402
1403 if (flags&MSG_OOB) 1403 if (flags&MSG_OOB)
1404 return -EOPNOTSUPP; 1404 return -EOPNOTSUPP;
1405 1405
1406 copied = 0; 1406 copied = 0;
1407 1407
1408 skb = skb_recv_datagram(sk, flags, noblock, &err); 1408 skb = skb_recv_datagram(sk, flags, noblock, &err);
1409 if (skb == NULL) 1409 if (skb == NULL)
1410 goto out; 1410 goto out;
1411 1411
1412 data_skb = skb; 1412 data_skb = skb;
1413 1413
1414 #ifdef CONFIG_COMPAT_NETLINK_MESSAGES 1414 #ifdef CONFIG_COMPAT_NETLINK_MESSAGES
1415 if (unlikely(skb_shinfo(skb)->frag_list)) { 1415 if (unlikely(skb_shinfo(skb)->frag_list)) {
1416 /* 1416 /*
1417 * If this skb has a frag_list, then here that means that we 1417 * If this skb has a frag_list, then here that means that we
1418 * will have to use the frag_list skb's data for compat tasks 1418 * will have to use the frag_list skb's data for compat tasks
1419 * and the regular skb's data for normal (non-compat) tasks. 1419 * and the regular skb's data for normal (non-compat) tasks.
1420 * 1420 *
1421 * If we need to send the compat skb, assign it to the 1421 * If we need to send the compat skb, assign it to the
1422 * 'data_skb' variable so that it will be used below for data 1422 * 'data_skb' variable so that it will be used below for data
1423 * copying. We keep 'skb' for everything else, including 1423 * copying. We keep 'skb' for everything else, including
1424 * freeing both later. 1424 * freeing both later.
1425 */ 1425 */
1426 if (flags & MSG_CMSG_COMPAT) 1426 if (flags & MSG_CMSG_COMPAT)
1427 data_skb = skb_shinfo(skb)->frag_list; 1427 data_skb = skb_shinfo(skb)->frag_list;
1428 } 1428 }
1429 #endif 1429 #endif
1430 1430
1431 msg->msg_namelen = 0; 1431 msg->msg_namelen = 0;
1432 1432
1433 copied = data_skb->len; 1433 copied = data_skb->len;
1434 if (len < copied) { 1434 if (len < copied) {
1435 msg->msg_flags |= MSG_TRUNC; 1435 msg->msg_flags |= MSG_TRUNC;
1436 copied = len; 1436 copied = len;
1437 } 1437 }
1438 1438
1439 skb_reset_transport_header(data_skb); 1439 skb_reset_transport_header(data_skb);
1440 err = skb_copy_datagram_iovec(data_skb, 0, msg->msg_iov, copied); 1440 err = skb_copy_datagram_iovec(data_skb, 0, msg->msg_iov, copied);
1441 1441
1442 if (msg->msg_name) { 1442 if (msg->msg_name) {
1443 struct sockaddr_nl *addr = (struct sockaddr_nl *)msg->msg_name; 1443 struct sockaddr_nl *addr = (struct sockaddr_nl *)msg->msg_name;
1444 addr->nl_family = AF_NETLINK; 1444 addr->nl_family = AF_NETLINK;
1445 addr->nl_pad = 0; 1445 addr->nl_pad = 0;
1446 addr->nl_pid = NETLINK_CB(skb).pid; 1446 addr->nl_pid = NETLINK_CB(skb).pid;
1447 addr->nl_groups = netlink_group_mask(NETLINK_CB(skb).dst_group); 1447 addr->nl_groups = netlink_group_mask(NETLINK_CB(skb).dst_group);
1448 msg->msg_namelen = sizeof(*addr); 1448 msg->msg_namelen = sizeof(*addr);
1449 } 1449 }
1450 1450
1451 if (nlk->flags & NETLINK_RECV_PKTINFO) 1451 if (nlk->flags & NETLINK_RECV_PKTINFO)
1452 netlink_cmsg_recv_pktinfo(msg, skb); 1452 netlink_cmsg_recv_pktinfo(msg, skb);
1453 1453
1454 if (NULL == siocb->scm) { 1454 if (NULL == siocb->scm) {
1455 memset(&scm, 0, sizeof(scm)); 1455 memset(&scm, 0, sizeof(scm));
1456 siocb->scm = &scm; 1456 siocb->scm = &scm;
1457 } 1457 }
1458 siocb->scm->creds = *NETLINK_CREDS(skb); 1458 siocb->scm->creds = *NETLINK_CREDS(skb);
1459 if (flags & MSG_TRUNC) 1459 if (flags & MSG_TRUNC)
1460 copied = data_skb->len; 1460 copied = data_skb->len;
1461 1461
1462 skb_free_datagram(sk, skb); 1462 skb_free_datagram(sk, skb);
1463 1463
1464 if (nlk->cb && atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf / 2) { 1464 if (nlk->cb && atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf / 2) {
1465 ret = netlink_dump(sk); 1465 ret = netlink_dump(sk);
1466 if (ret) { 1466 if (ret) {
1467 sk->sk_err = ret; 1467 sk->sk_err = ret;
1468 sk->sk_error_report(sk); 1468 sk->sk_error_report(sk);
1469 } 1469 }
1470 } 1470 }
1471 1471
1472 scm_recv(sock, msg, siocb->scm, flags); 1472 scm_recv(sock, msg, siocb->scm, flags);
1473 out: 1473 out:
1474 netlink_rcv_wake(sk); 1474 netlink_rcv_wake(sk);
1475 return err ? : copied; 1475 return err ? : copied;
1476 } 1476 }
1477 1477
1478 static void netlink_data_ready(struct sock *sk, int len) 1478 static void netlink_data_ready(struct sock *sk, int len)
1479 { 1479 {
1480 BUG(); 1480 BUG();
1481 } 1481 }
1482 1482
1483 /* 1483 /*
1484 * We export these functions to other modules. They provide a 1484 * We export these functions to other modules. They provide a
1485 * complete set of kernel non-blocking support for message 1485 * complete set of kernel non-blocking support for message
1486 * queueing. 1486 * queueing.
1487 */ 1487 */
1488 1488
1489 struct sock * 1489 struct sock *
1490 netlink_kernel_create(struct net *net, int unit, unsigned int groups, 1490 netlink_kernel_create(struct net *net, int unit, unsigned int groups,
1491 void (*input)(struct sk_buff *skb), 1491 void (*input)(struct sk_buff *skb),
1492 struct mutex *cb_mutex, struct module *module) 1492 struct mutex *cb_mutex, struct module *module)
1493 { 1493 {
1494 struct socket *sock; 1494 struct socket *sock;
1495 struct sock *sk; 1495 struct sock *sk;
1496 struct netlink_sock *nlk; 1496 struct netlink_sock *nlk;
1497 struct listeners *listeners = NULL; 1497 struct listeners *listeners = NULL;
1498 1498
1499 BUG_ON(!nl_table); 1499 BUG_ON(!nl_table);
1500 1500
1501 if (unit < 0 || unit >= MAX_LINKS) 1501 if (unit < 0 || unit >= MAX_LINKS)
1502 return NULL; 1502 return NULL;
1503 1503
1504 if (sock_create_lite(PF_NETLINK, SOCK_DGRAM, unit, &sock)) 1504 if (sock_create_lite(PF_NETLINK, SOCK_DGRAM, unit, &sock))
1505 return NULL; 1505 return NULL;
1506 1506
1507 /* 1507 /*
1508 * We have to just have a reference on the net from sk, but don't 1508 * We have to just have a reference on the net from sk, but don't
1509 * get_net it. Besides, we cannot get and then put the net here. 1509 * get_net it. Besides, we cannot get and then put the net here.
1510 * So we create one inside init_net and the move it to net. 1510 * So we create one inside init_net and the move it to net.
1511 */ 1511 */
1512 1512
1513 if (__netlink_create(&init_net, sock, cb_mutex, unit) < 0) 1513 if (__netlink_create(&init_net, sock, cb_mutex, unit) < 0)
1514 goto out_sock_release_nosk; 1514 goto out_sock_release_nosk;
1515 1515
1516 sk = sock->sk; 1516 sk = sock->sk;
1517 sk_change_net(sk, net); 1517 sk_change_net(sk, net);
1518 1518
1519 if (groups < 32) 1519 if (groups < 32)
1520 groups = 32; 1520 groups = 32;
1521 1521
1522 listeners = kzalloc(sizeof(*listeners) + NLGRPSZ(groups), GFP_KERNEL); 1522 listeners = kzalloc(sizeof(*listeners) + NLGRPSZ(groups), GFP_KERNEL);
1523 if (!listeners) 1523 if (!listeners)
1524 goto out_sock_release; 1524 goto out_sock_release;
1525 1525
1526 sk->sk_data_ready = netlink_data_ready; 1526 sk->sk_data_ready = netlink_data_ready;
1527 if (input) 1527 if (input)
1528 nlk_sk(sk)->netlink_rcv = input; 1528 nlk_sk(sk)->netlink_rcv = input;
1529 1529
1530 if (netlink_insert(sk, net, 0)) 1530 if (netlink_insert(sk, net, 0))
1531 goto out_sock_release; 1531 goto out_sock_release;
1532 1532
1533 nlk = nlk_sk(sk); 1533 nlk = nlk_sk(sk);
1534 nlk->flags |= NETLINK_KERNEL_SOCKET; 1534 nlk->flags |= NETLINK_KERNEL_SOCKET;
1535 1535
1536 netlink_table_grab(); 1536 netlink_table_grab();
1537 if (!nl_table[unit].registered) { 1537 if (!nl_table[unit].registered) {
1538 nl_table[unit].groups = groups; 1538 nl_table[unit].groups = groups;
1539 rcu_assign_pointer(nl_table[unit].listeners, listeners); 1539 rcu_assign_pointer(nl_table[unit].listeners, listeners);
1540 nl_table[unit].cb_mutex = cb_mutex; 1540 nl_table[unit].cb_mutex = cb_mutex;
1541 nl_table[unit].module = module; 1541 nl_table[unit].module = module;
1542 nl_table[unit].registered = 1; 1542 nl_table[unit].registered = 1;
1543 } else { 1543 } else {
1544 kfree(listeners); 1544 kfree(listeners);
1545 nl_table[unit].registered++; 1545 nl_table[unit].registered++;
1546 } 1546 }
1547 netlink_table_ungrab(); 1547 netlink_table_ungrab();
1548 return sk; 1548 return sk;
1549 1549
1550 out_sock_release: 1550 out_sock_release:
1551 kfree(listeners); 1551 kfree(listeners);
1552 netlink_kernel_release(sk); 1552 netlink_kernel_release(sk);
1553 return NULL; 1553 return NULL;
1554 1554
1555 out_sock_release_nosk: 1555 out_sock_release_nosk:
1556 sock_release(sock); 1556 sock_release(sock);
1557 return NULL; 1557 return NULL;
1558 } 1558 }
1559 EXPORT_SYMBOL(netlink_kernel_create); 1559 EXPORT_SYMBOL(netlink_kernel_create);
1560 1560
1561 1561
1562 void 1562 void
1563 netlink_kernel_release(struct sock *sk) 1563 netlink_kernel_release(struct sock *sk)
1564 { 1564 {
1565 sk_release_kernel(sk); 1565 sk_release_kernel(sk);
1566 } 1566 }
1567 EXPORT_SYMBOL(netlink_kernel_release); 1567 EXPORT_SYMBOL(netlink_kernel_release);
1568 1568
1569 int __netlink_change_ngroups(struct sock *sk, unsigned int groups) 1569 int __netlink_change_ngroups(struct sock *sk, unsigned int groups)
1570 { 1570 {
1571 struct listeners *new, *old; 1571 struct listeners *new, *old;
1572 struct netlink_table *tbl = &nl_table[sk->sk_protocol]; 1572 struct netlink_table *tbl = &nl_table[sk->sk_protocol];
1573 1573
1574 if (groups < 32) 1574 if (groups < 32)
1575 groups = 32; 1575 groups = 32;
1576 1576
1577 if (NLGRPSZ(tbl->groups) < NLGRPSZ(groups)) { 1577 if (NLGRPSZ(tbl->groups) < NLGRPSZ(groups)) {
1578 new = kzalloc(sizeof(*new) + NLGRPSZ(groups), GFP_ATOMIC); 1578 new = kzalloc(sizeof(*new) + NLGRPSZ(groups), GFP_ATOMIC);
1579 if (!new) 1579 if (!new)
1580 return -ENOMEM; 1580 return -ENOMEM;
1581 old = rcu_dereference_raw(tbl->listeners); 1581 old = rcu_dereference_raw(tbl->listeners);
1582 memcpy(new->masks, old->masks, NLGRPSZ(tbl->groups)); 1582 memcpy(new->masks, old->masks, NLGRPSZ(tbl->groups));
1583 rcu_assign_pointer(tbl->listeners, new); 1583 rcu_assign_pointer(tbl->listeners, new);
1584 1584
1585 kfree_rcu(old, rcu); 1585 kfree_rcu(old, rcu);
1586 } 1586 }
1587 tbl->groups = groups; 1587 tbl->groups = groups;
1588 1588
1589 return 0; 1589 return 0;
1590 } 1590 }
1591 1591
1592 /** 1592 /**
1593 * netlink_change_ngroups - change number of multicast groups 1593 * netlink_change_ngroups - change number of multicast groups
1594 * 1594 *
1595 * This changes the number of multicast groups that are available 1595 * This changes the number of multicast groups that are available
1596 * on a certain netlink family. Note that it is not possible to 1596 * on a certain netlink family. Note that it is not possible to
1597 * change the number of groups to below 32. Also note that it does 1597 * change the number of groups to below 32. Also note that it does
1598 * not implicitly call netlink_clear_multicast_users() when the 1598 * not implicitly call netlink_clear_multicast_users() when the
1599 * number of groups is reduced. 1599 * number of groups is reduced.
1600 * 1600 *
1601 * @sk: The kernel netlink socket, as returned by netlink_kernel_create(). 1601 * @sk: The kernel netlink socket, as returned by netlink_kernel_create().
1602 * @groups: The new number of groups. 1602 * @groups: The new number of groups.
1603 */ 1603 */
1604 int netlink_change_ngroups(struct sock *sk, unsigned int groups) 1604 int netlink_change_ngroups(struct sock *sk, unsigned int groups)
1605 { 1605 {
1606 int err; 1606 int err;
1607 1607
1608 netlink_table_grab(); 1608 netlink_table_grab();
1609 err = __netlink_change_ngroups(sk, groups); 1609 err = __netlink_change_ngroups(sk, groups);
1610 netlink_table_ungrab(); 1610 netlink_table_ungrab();
1611 1611
1612 return err; 1612 return err;
1613 } 1613 }
1614 1614
1615 void __netlink_clear_multicast_users(struct sock *ksk, unsigned int group) 1615 void __netlink_clear_multicast_users(struct sock *ksk, unsigned int group)
1616 { 1616 {
1617 struct sock *sk; 1617 struct sock *sk;
1618 struct hlist_node *node; 1618 struct hlist_node *node;
1619 struct netlink_table *tbl = &nl_table[ksk->sk_protocol]; 1619 struct netlink_table *tbl = &nl_table[ksk->sk_protocol];
1620 1620
1621 sk_for_each_bound(sk, node, &tbl->mc_list) 1621 sk_for_each_bound(sk, node, &tbl->mc_list)
1622 netlink_update_socket_mc(nlk_sk(sk), group, 0); 1622 netlink_update_socket_mc(nlk_sk(sk), group, 0);
1623 } 1623 }
1624 1624
1625 /** 1625 /**
1626 * netlink_clear_multicast_users - kick off multicast listeners 1626 * netlink_clear_multicast_users - kick off multicast listeners
1627 * 1627 *
1628 * This function removes all listeners from the given group. 1628 * This function removes all listeners from the given group.
1629 * @ksk: The kernel netlink socket, as returned by 1629 * @ksk: The kernel netlink socket, as returned by
1630 * netlink_kernel_create(). 1630 * netlink_kernel_create().
1631 * @group: The multicast group to clear. 1631 * @group: The multicast group to clear.
1632 */ 1632 */
1633 void netlink_clear_multicast_users(struct sock *ksk, unsigned int group) 1633 void netlink_clear_multicast_users(struct sock *ksk, unsigned int group)
1634 { 1634 {
1635 netlink_table_grab(); 1635 netlink_table_grab();
1636 __netlink_clear_multicast_users(ksk, group); 1636 __netlink_clear_multicast_users(ksk, group);
1637 netlink_table_ungrab(); 1637 netlink_table_ungrab();
1638 } 1638 }
1639 1639
1640 void netlink_set_nonroot(int protocol, unsigned int flags) 1640 void netlink_set_nonroot(int protocol, unsigned int flags)
1641 { 1641 {
1642 if ((unsigned int)protocol < MAX_LINKS) 1642 if ((unsigned int)protocol < MAX_LINKS)
1643 nl_table[protocol].nl_nonroot = flags; 1643 nl_table[protocol].nl_nonroot = flags;
1644 } 1644 }
1645 EXPORT_SYMBOL(netlink_set_nonroot); 1645 EXPORT_SYMBOL(netlink_set_nonroot);
1646 1646
1647 static void netlink_destroy_callback(struct netlink_callback *cb) 1647 static void netlink_destroy_callback(struct netlink_callback *cb)
1648 { 1648 {
1649 kfree_skb(cb->skb); 1649 kfree_skb(cb->skb);
1650 kfree(cb); 1650 kfree(cb);
1651 } 1651 }
1652 1652
1653 /* 1653 /*
1654 * It looks a bit ugly. 1654 * It looks a bit ugly.
1655 * It would be better to create kernel thread. 1655 * It would be better to create kernel thread.
1656 */ 1656 */
1657 1657
1658 static int netlink_dump(struct sock *sk) 1658 static int netlink_dump(struct sock *sk)
1659 { 1659 {
1660 struct netlink_sock *nlk = nlk_sk(sk); 1660 struct netlink_sock *nlk = nlk_sk(sk);
1661 struct netlink_callback *cb; 1661 struct netlink_callback *cb;
1662 struct sk_buff *skb = NULL; 1662 struct sk_buff *skb = NULL;
1663 struct nlmsghdr *nlh; 1663 struct nlmsghdr *nlh;
1664 int len, err = -ENOBUFS; 1664 int len, err = -ENOBUFS;
1665 int alloc_size; 1665 int alloc_size;
1666 1666
1667 mutex_lock(nlk->cb_mutex); 1667 mutex_lock(nlk->cb_mutex);
1668 1668
1669 cb = nlk->cb; 1669 cb = nlk->cb;
1670 if (cb == NULL) { 1670 if (cb == NULL) {
1671 err = -EINVAL; 1671 err = -EINVAL;
1672 goto errout_skb; 1672 goto errout_skb;
1673 } 1673 }
1674 1674
1675 alloc_size = max_t(int, cb->min_dump_alloc, NLMSG_GOODSIZE); 1675 alloc_size = max_t(int, cb->min_dump_alloc, NLMSG_GOODSIZE);
1676 1676
1677 skb = sock_rmalloc(sk, alloc_size, 0, GFP_KERNEL); 1677 skb = sock_rmalloc(sk, alloc_size, 0, GFP_KERNEL);
1678 if (!skb) 1678 if (!skb)
1679 goto errout; 1679 goto errout_skb;
1680 1680
1681 len = cb->dump(skb, cb); 1681 len = cb->dump(skb, cb);
1682 1682
1683 if (len > 0) { 1683 if (len > 0) {
1684 mutex_unlock(nlk->cb_mutex); 1684 mutex_unlock(nlk->cb_mutex);
1685 1685
1686 if (sk_filter(sk, skb)) 1686 if (sk_filter(sk, skb))
1687 kfree_skb(skb); 1687 kfree_skb(skb);
1688 else { 1688 else {
1689 skb_queue_tail(&sk->sk_receive_queue, skb); 1689 skb_queue_tail(&sk->sk_receive_queue, skb);
1690 sk->sk_data_ready(sk, skb->len); 1690 sk->sk_data_ready(sk, skb->len);
1691 } 1691 }
1692 return 0; 1692 return 0;
1693 } 1693 }
1694 1694
1695 nlh = nlmsg_put_answer(skb, cb, NLMSG_DONE, sizeof(len), NLM_F_MULTI); 1695 nlh = nlmsg_put_answer(skb, cb, NLMSG_DONE, sizeof(len), NLM_F_MULTI);
1696 if (!nlh) 1696 if (!nlh)
1697 goto errout_skb; 1697 goto errout_skb;
1698 1698
1699 memcpy(nlmsg_data(nlh), &len, sizeof(len)); 1699 memcpy(nlmsg_data(nlh), &len, sizeof(len));
1700 1700
1701 if (sk_filter(sk, skb)) 1701 if (sk_filter(sk, skb))
1702 kfree_skb(skb); 1702 kfree_skb(skb);
1703 else { 1703 else {
1704 skb_queue_tail(&sk->sk_receive_queue, skb); 1704 skb_queue_tail(&sk->sk_receive_queue, skb);
1705 sk->sk_data_ready(sk, skb->len); 1705 sk->sk_data_ready(sk, skb->len);
1706 } 1706 }
1707 1707
1708 if (cb->done) 1708 if (cb->done)
1709 cb->done(cb); 1709 cb->done(cb);
1710 nlk->cb = NULL; 1710 nlk->cb = NULL;
1711 mutex_unlock(nlk->cb_mutex); 1711 mutex_unlock(nlk->cb_mutex);
1712 1712
1713 netlink_destroy_callback(cb); 1713 netlink_destroy_callback(cb);
1714 return 0; 1714 return 0;
1715 1715
1716 errout_skb: 1716 errout_skb:
1717 mutex_unlock(nlk->cb_mutex); 1717 mutex_unlock(nlk->cb_mutex);
1718 kfree_skb(skb); 1718 kfree_skb(skb);
1719 errout:
1720 return err; 1719 return err;
1721 } 1720 }
1722 1721
1723 int netlink_dump_start(struct sock *ssk, struct sk_buff *skb, 1722 int netlink_dump_start(struct sock *ssk, struct sk_buff *skb,
1724 const struct nlmsghdr *nlh, 1723 const struct nlmsghdr *nlh,
1725 int (*dump)(struct sk_buff *skb, 1724 int (*dump)(struct sk_buff *skb,
1726 struct netlink_callback *), 1725 struct netlink_callback *),
1727 int (*done)(struct netlink_callback *), 1726 int (*done)(struct netlink_callback *),
1728 u16 min_dump_alloc) 1727 u16 min_dump_alloc)
1729 { 1728 {
1730 struct netlink_callback *cb; 1729 struct netlink_callback *cb;
1731 struct sock *sk; 1730 struct sock *sk;
1732 struct netlink_sock *nlk; 1731 struct netlink_sock *nlk;
1733 int ret; 1732 int ret;
1734 1733
1735 cb = kzalloc(sizeof(*cb), GFP_KERNEL); 1734 cb = kzalloc(sizeof(*cb), GFP_KERNEL);
1736 if (cb == NULL) 1735 if (cb == NULL)
1737 return -ENOBUFS; 1736 return -ENOBUFS;
1738 1737
1739 cb->dump = dump; 1738 cb->dump = dump;
1740 cb->done = done; 1739 cb->done = done;
1741 cb->nlh = nlh; 1740 cb->nlh = nlh;
1742 cb->min_dump_alloc = min_dump_alloc; 1741 cb->min_dump_alloc = min_dump_alloc;
1743 atomic_inc(&skb->users); 1742 atomic_inc(&skb->users);
1744 cb->skb = skb; 1743 cb->skb = skb;
1745 1744
1746 sk = netlink_lookup(sock_net(ssk), ssk->sk_protocol, NETLINK_CB(skb).pid); 1745 sk = netlink_lookup(sock_net(ssk), ssk->sk_protocol, NETLINK_CB(skb).pid);
1747 if (sk == NULL) { 1746 if (sk == NULL) {
1748 netlink_destroy_callback(cb); 1747 netlink_destroy_callback(cb);
1749 return -ECONNREFUSED; 1748 return -ECONNREFUSED;
1750 } 1749 }
1751 nlk = nlk_sk(sk); 1750 nlk = nlk_sk(sk);
1752 /* A dump is in progress... */ 1751 /* A dump is in progress... */
1753 mutex_lock(nlk->cb_mutex); 1752 mutex_lock(nlk->cb_mutex);
1754 if (nlk->cb) { 1753 if (nlk->cb) {
1755 mutex_unlock(nlk->cb_mutex); 1754 mutex_unlock(nlk->cb_mutex);
1756 netlink_destroy_callback(cb); 1755 netlink_destroy_callback(cb);
1757 sock_put(sk); 1756 sock_put(sk);
1758 return -EBUSY; 1757 return -EBUSY;
1759 } 1758 }
1760 nlk->cb = cb; 1759 nlk->cb = cb;
1761 mutex_unlock(nlk->cb_mutex); 1760 mutex_unlock(nlk->cb_mutex);
1762 1761
1763 ret = netlink_dump(sk); 1762 ret = netlink_dump(sk);
1764 1763
1765 sock_put(sk); 1764 sock_put(sk);
1766 1765
1767 if (ret) 1766 if (ret)
1768 return ret; 1767 return ret;
1769 1768
1770 /* We successfully started a dump, by returning -EINTR we 1769 /* We successfully started a dump, by returning -EINTR we
1771 * signal not to send ACK even if it was requested. 1770 * signal not to send ACK even if it was requested.
1772 */ 1771 */
1773 return -EINTR; 1772 return -EINTR;
1774 } 1773 }
1775 EXPORT_SYMBOL(netlink_dump_start); 1774 EXPORT_SYMBOL(netlink_dump_start);
1776 1775
1777 void netlink_ack(struct sk_buff *in_skb, struct nlmsghdr *nlh, int err) 1776 void netlink_ack(struct sk_buff *in_skb, struct nlmsghdr *nlh, int err)
1778 { 1777 {
1779 struct sk_buff *skb; 1778 struct sk_buff *skb;
1780 struct nlmsghdr *rep; 1779 struct nlmsghdr *rep;
1781 struct nlmsgerr *errmsg; 1780 struct nlmsgerr *errmsg;
1782 size_t payload = sizeof(*errmsg); 1781 size_t payload = sizeof(*errmsg);
1783 1782
1784 /* error messages get the original request appened */ 1783 /* error messages get the original request appened */
1785 if (err) 1784 if (err)
1786 payload += nlmsg_len(nlh); 1785 payload += nlmsg_len(nlh);
1787 1786
1788 skb = nlmsg_new(payload, GFP_KERNEL); 1787 skb = nlmsg_new(payload, GFP_KERNEL);
1789 if (!skb) { 1788 if (!skb) {
1790 struct sock *sk; 1789 struct sock *sk;
1791 1790
1792 sk = netlink_lookup(sock_net(in_skb->sk), 1791 sk = netlink_lookup(sock_net(in_skb->sk),
1793 in_skb->sk->sk_protocol, 1792 in_skb->sk->sk_protocol,
1794 NETLINK_CB(in_skb).pid); 1793 NETLINK_CB(in_skb).pid);
1795 if (sk) { 1794 if (sk) {
1796 sk->sk_err = ENOBUFS; 1795 sk->sk_err = ENOBUFS;
1797 sk->sk_error_report(sk); 1796 sk->sk_error_report(sk);
1798 sock_put(sk); 1797 sock_put(sk);
1799 } 1798 }
1800 return; 1799 return;
1801 } 1800 }
1802 1801
1803 rep = __nlmsg_put(skb, NETLINK_CB(in_skb).pid, nlh->nlmsg_seq, 1802 rep = __nlmsg_put(skb, NETLINK_CB(in_skb).pid, nlh->nlmsg_seq,
1804 NLMSG_ERROR, payload, 0); 1803 NLMSG_ERROR, payload, 0);
1805 errmsg = nlmsg_data(rep); 1804 errmsg = nlmsg_data(rep);
1806 errmsg->error = err; 1805 errmsg->error = err;
1807 memcpy(&errmsg->msg, nlh, err ? nlh->nlmsg_len : sizeof(*nlh)); 1806 memcpy(&errmsg->msg, nlh, err ? nlh->nlmsg_len : sizeof(*nlh));
1808 netlink_unicast(in_skb->sk, skb, NETLINK_CB(in_skb).pid, MSG_DONTWAIT); 1807 netlink_unicast(in_skb->sk, skb, NETLINK_CB(in_skb).pid, MSG_DONTWAIT);
1809 } 1808 }
1810 EXPORT_SYMBOL(netlink_ack); 1809 EXPORT_SYMBOL(netlink_ack);
1811 1810
1812 int netlink_rcv_skb(struct sk_buff *skb, int (*cb)(struct sk_buff *, 1811 int netlink_rcv_skb(struct sk_buff *skb, int (*cb)(struct sk_buff *,
1813 struct nlmsghdr *)) 1812 struct nlmsghdr *))
1814 { 1813 {
1815 struct nlmsghdr *nlh; 1814 struct nlmsghdr *nlh;
1816 int err; 1815 int err;
1817 1816
1818 while (skb->len >= nlmsg_total_size(0)) { 1817 while (skb->len >= nlmsg_total_size(0)) {
1819 int msglen; 1818 int msglen;
1820 1819
1821 nlh = nlmsg_hdr(skb); 1820 nlh = nlmsg_hdr(skb);
1822 err = 0; 1821 err = 0;
1823 1822
1824 if (nlh->nlmsg_len < NLMSG_HDRLEN || skb->len < nlh->nlmsg_len) 1823 if (nlh->nlmsg_len < NLMSG_HDRLEN || skb->len < nlh->nlmsg_len)
1825 return 0; 1824 return 0;
1826 1825
1827 /* Only requests are handled by the kernel */ 1826 /* Only requests are handled by the kernel */
1828 if (!(nlh->nlmsg_flags & NLM_F_REQUEST)) 1827 if (!(nlh->nlmsg_flags & NLM_F_REQUEST))
1829 goto ack; 1828 goto ack;
1830 1829
1831 /* Skip control messages */ 1830 /* Skip control messages */
1832 if (nlh->nlmsg_type < NLMSG_MIN_TYPE) 1831 if (nlh->nlmsg_type < NLMSG_MIN_TYPE)
1833 goto ack; 1832 goto ack;
1834 1833
1835 err = cb(skb, nlh); 1834 err = cb(skb, nlh);
1836 if (err == -EINTR) 1835 if (err == -EINTR)
1837 goto skip; 1836 goto skip;
1838 1837
1839 ack: 1838 ack:
1840 if (nlh->nlmsg_flags & NLM_F_ACK || err) 1839 if (nlh->nlmsg_flags & NLM_F_ACK || err)
1841 netlink_ack(skb, nlh, err); 1840 netlink_ack(skb, nlh, err);
1842 1841
1843 skip: 1842 skip:
1844 msglen = NLMSG_ALIGN(nlh->nlmsg_len); 1843 msglen = NLMSG_ALIGN(nlh->nlmsg_len);
1845 if (msglen > skb->len) 1844 if (msglen > skb->len)
1846 msglen = skb->len; 1845 msglen = skb->len;
1847 skb_pull(skb, msglen); 1846 skb_pull(skb, msglen);
1848 } 1847 }
1849 1848
1850 return 0; 1849 return 0;
1851 } 1850 }
1852 EXPORT_SYMBOL(netlink_rcv_skb); 1851 EXPORT_SYMBOL(netlink_rcv_skb);
1853 1852
1854 /** 1853 /**
1855 * nlmsg_notify - send a notification netlink message 1854 * nlmsg_notify - send a notification netlink message
1856 * @sk: netlink socket to use 1855 * @sk: netlink socket to use
1857 * @skb: notification message 1856 * @skb: notification message
1858 * @pid: destination netlink pid for reports or 0 1857 * @pid: destination netlink pid for reports or 0
1859 * @group: destination multicast group or 0 1858 * @group: destination multicast group or 0
1860 * @report: 1 to report back, 0 to disable 1859 * @report: 1 to report back, 0 to disable
1861 * @flags: allocation flags 1860 * @flags: allocation flags
1862 */ 1861 */
1863 int nlmsg_notify(struct sock *sk, struct sk_buff *skb, u32 pid, 1862 int nlmsg_notify(struct sock *sk, struct sk_buff *skb, u32 pid,
1864 unsigned int group, int report, gfp_t flags) 1863 unsigned int group, int report, gfp_t flags)
1865 { 1864 {
1866 int err = 0; 1865 int err = 0;
1867 1866
1868 if (group) { 1867 if (group) {
1869 int exclude_pid = 0; 1868 int exclude_pid = 0;
1870 1869
1871 if (report) { 1870 if (report) {
1872 atomic_inc(&skb->users); 1871 atomic_inc(&skb->users);
1873 exclude_pid = pid; 1872 exclude_pid = pid;
1874 } 1873 }
1875 1874
1876 /* errors reported via destination sk->sk_err, but propagate 1875 /* errors reported via destination sk->sk_err, but propagate
1877 * delivery errors if NETLINK_BROADCAST_ERROR flag is set */ 1876 * delivery errors if NETLINK_BROADCAST_ERROR flag is set */
1878 err = nlmsg_multicast(sk, skb, exclude_pid, group, flags); 1877 err = nlmsg_multicast(sk, skb, exclude_pid, group, flags);
1879 } 1878 }
1880 1879
1881 if (report) { 1880 if (report) {
1882 int err2; 1881 int err2;
1883 1882
1884 err2 = nlmsg_unicast(sk, skb, pid); 1883 err2 = nlmsg_unicast(sk, skb, pid);
1885 if (!err || err == -ESRCH) 1884 if (!err || err == -ESRCH)
1886 err = err2; 1885 err = err2;
1887 } 1886 }
1888 1887
1889 return err; 1888 return err;
1890 } 1889 }
1891 EXPORT_SYMBOL(nlmsg_notify); 1890 EXPORT_SYMBOL(nlmsg_notify);
1892 1891
1893 #ifdef CONFIG_PROC_FS 1892 #ifdef CONFIG_PROC_FS
1894 struct nl_seq_iter { 1893 struct nl_seq_iter {
1895 struct seq_net_private p; 1894 struct seq_net_private p;
1896 int link; 1895 int link;
1897 int hash_idx; 1896 int hash_idx;
1898 }; 1897 };
1899 1898
1900 static struct sock *netlink_seq_socket_idx(struct seq_file *seq, loff_t pos) 1899 static struct sock *netlink_seq_socket_idx(struct seq_file *seq, loff_t pos)
1901 { 1900 {
1902 struct nl_seq_iter *iter = seq->private; 1901 struct nl_seq_iter *iter = seq->private;
1903 int i, j; 1902 int i, j;
1904 struct sock *s; 1903 struct sock *s;
1905 struct hlist_node *node; 1904 struct hlist_node *node;
1906 loff_t off = 0; 1905 loff_t off = 0;
1907 1906
1908 for (i = 0; i < MAX_LINKS; i++) { 1907 for (i = 0; i < MAX_LINKS; i++) {
1909 struct nl_pid_hash *hash = &nl_table[i].hash; 1908 struct nl_pid_hash *hash = &nl_table[i].hash;
1910 1909
1911 for (j = 0; j <= hash->mask; j++) { 1910 for (j = 0; j <= hash->mask; j++) {
1912 sk_for_each(s, node, &hash->table[j]) { 1911 sk_for_each(s, node, &hash->table[j]) {
1913 if (sock_net(s) != seq_file_net(seq)) 1912 if (sock_net(s) != seq_file_net(seq))
1914 continue; 1913 continue;
1915 if (off == pos) { 1914 if (off == pos) {
1916 iter->link = i; 1915 iter->link = i;
1917 iter->hash_idx = j; 1916 iter->hash_idx = j;
1918 return s; 1917 return s;
1919 } 1918 }
1920 ++off; 1919 ++off;
1921 } 1920 }
1922 } 1921 }
1923 } 1922 }
1924 return NULL; 1923 return NULL;
1925 } 1924 }
1926 1925
1927 static void *netlink_seq_start(struct seq_file *seq, loff_t *pos) 1926 static void *netlink_seq_start(struct seq_file *seq, loff_t *pos)
1928 __acquires(nl_table_lock) 1927 __acquires(nl_table_lock)
1929 { 1928 {
1930 read_lock(&nl_table_lock); 1929 read_lock(&nl_table_lock);
1931 return *pos ? netlink_seq_socket_idx(seq, *pos - 1) : SEQ_START_TOKEN; 1930 return *pos ? netlink_seq_socket_idx(seq, *pos - 1) : SEQ_START_TOKEN;
1932 } 1931 }
1933 1932
1934 static void *netlink_seq_next(struct seq_file *seq, void *v, loff_t *pos) 1933 static void *netlink_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1935 { 1934 {
1936 struct sock *s; 1935 struct sock *s;
1937 struct nl_seq_iter *iter; 1936 struct nl_seq_iter *iter;
1938 int i, j; 1937 int i, j;
1939 1938
1940 ++*pos; 1939 ++*pos;
1941 1940
1942 if (v == SEQ_START_TOKEN) 1941 if (v == SEQ_START_TOKEN)
1943 return netlink_seq_socket_idx(seq, 0); 1942 return netlink_seq_socket_idx(seq, 0);
1944 1943
1945 iter = seq->private; 1944 iter = seq->private;
1946 s = v; 1945 s = v;
1947 do { 1946 do {
1948 s = sk_next(s); 1947 s = sk_next(s);
1949 } while (s && sock_net(s) != seq_file_net(seq)); 1948 } while (s && sock_net(s) != seq_file_net(seq));
1950 if (s) 1949 if (s)
1951 return s; 1950 return s;
1952 1951
1953 i = iter->link; 1952 i = iter->link;
1954 j = iter->hash_idx + 1; 1953 j = iter->hash_idx + 1;
1955 1954
1956 do { 1955 do {
1957 struct nl_pid_hash *hash = &nl_table[i].hash; 1956 struct nl_pid_hash *hash = &nl_table[i].hash;
1958 1957
1959 for (; j <= hash->mask; j++) { 1958 for (; j <= hash->mask; j++) {
1960 s = sk_head(&hash->table[j]); 1959 s = sk_head(&hash->table[j]);
1961 while (s && sock_net(s) != seq_file_net(seq)) 1960 while (s && sock_net(s) != seq_file_net(seq))
1962 s = sk_next(s); 1961 s = sk_next(s);
1963 if (s) { 1962 if (s) {
1964 iter->link = i; 1963 iter->link = i;
1965 iter->hash_idx = j; 1964 iter->hash_idx = j;
1966 return s; 1965 return s;
1967 } 1966 }
1968 } 1967 }
1969 1968
1970 j = 0; 1969 j = 0;
1971 } while (++i < MAX_LINKS); 1970 } while (++i < MAX_LINKS);
1972 1971
1973 return NULL; 1972 return NULL;
1974 } 1973 }
1975 1974
1976 static void netlink_seq_stop(struct seq_file *seq, void *v) 1975 static void netlink_seq_stop(struct seq_file *seq, void *v)
1977 __releases(nl_table_lock) 1976 __releases(nl_table_lock)
1978 { 1977 {
1979 read_unlock(&nl_table_lock); 1978 read_unlock(&nl_table_lock);
1980 } 1979 }
1981 1980
1982 1981
1983 static int netlink_seq_show(struct seq_file *seq, void *v) 1982 static int netlink_seq_show(struct seq_file *seq, void *v)
1984 { 1983 {
1985 if (v == SEQ_START_TOKEN) 1984 if (v == SEQ_START_TOKEN)
1986 seq_puts(seq, 1985 seq_puts(seq,
1987 "sk Eth Pid Groups " 1986 "sk Eth Pid Groups "
1988 "Rmem Wmem Dump Locks Drops Inode\n"); 1987 "Rmem Wmem Dump Locks Drops Inode\n");
1989 else { 1988 else {
1990 struct sock *s = v; 1989 struct sock *s = v;
1991 struct netlink_sock *nlk = nlk_sk(s); 1990 struct netlink_sock *nlk = nlk_sk(s);
1992 1991
1993 seq_printf(seq, "%pK %-3d %-6d %08x %-8d %-8d %pK %-8d %-8d %-8lu\n", 1992 seq_printf(seq, "%pK %-3d %-6d %08x %-8d %-8d %pK %-8d %-8d %-8lu\n",
1994 s, 1993 s,
1995 s->sk_protocol, 1994 s->sk_protocol,
1996 nlk->pid, 1995 nlk->pid,
1997 nlk->groups ? (u32)nlk->groups[0] : 0, 1996 nlk->groups ? (u32)nlk->groups[0] : 0,
1998 sk_rmem_alloc_get(s), 1997 sk_rmem_alloc_get(s),
1999 sk_wmem_alloc_get(s), 1998 sk_wmem_alloc_get(s),
2000 nlk->cb, 1999 nlk->cb,
2001 atomic_read(&s->sk_refcnt), 2000 atomic_read(&s->sk_refcnt),
2002 atomic_read(&s->sk_drops), 2001 atomic_read(&s->sk_drops),
2003 sock_i_ino(s) 2002 sock_i_ino(s)
2004 ); 2003 );
2005 2004
2006 } 2005 }
2007 return 0; 2006 return 0;
2008 } 2007 }
2009 2008
2010 static const struct seq_operations netlink_seq_ops = { 2009 static const struct seq_operations netlink_seq_ops = {
2011 .start = netlink_seq_start, 2010 .start = netlink_seq_start,
2012 .next = netlink_seq_next, 2011 .next = netlink_seq_next,
2013 .stop = netlink_seq_stop, 2012 .stop = netlink_seq_stop,
2014 .show = netlink_seq_show, 2013 .show = netlink_seq_show,
2015 }; 2014 };
2016 2015
2017 2016
2018 static int netlink_seq_open(struct inode *inode, struct file *file) 2017 static int netlink_seq_open(struct inode *inode, struct file *file)
2019 { 2018 {
2020 return seq_open_net(inode, file, &netlink_seq_ops, 2019 return seq_open_net(inode, file, &netlink_seq_ops,
2021 sizeof(struct nl_seq_iter)); 2020 sizeof(struct nl_seq_iter));
2022 } 2021 }
2023 2022
2024 static const struct file_operations netlink_seq_fops = { 2023 static const struct file_operations netlink_seq_fops = {
2025 .owner = THIS_MODULE, 2024 .owner = THIS_MODULE,
2026 .open = netlink_seq_open, 2025 .open = netlink_seq_open,
2027 .read = seq_read, 2026 .read = seq_read,
2028 .llseek = seq_lseek, 2027 .llseek = seq_lseek,
2029 .release = seq_release_net, 2028 .release = seq_release_net,
2030 }; 2029 };
2031 2030
2032 #endif 2031 #endif
2033 2032
2034 int netlink_register_notifier(struct notifier_block *nb) 2033 int netlink_register_notifier(struct notifier_block *nb)
2035 { 2034 {
2036 return atomic_notifier_chain_register(&netlink_chain, nb); 2035 return atomic_notifier_chain_register(&netlink_chain, nb);
2037 } 2036 }
2038 EXPORT_SYMBOL(netlink_register_notifier); 2037 EXPORT_SYMBOL(netlink_register_notifier);
2039 2038
2040 int netlink_unregister_notifier(struct notifier_block *nb) 2039 int netlink_unregister_notifier(struct notifier_block *nb)
2041 { 2040 {
2042 return atomic_notifier_chain_unregister(&netlink_chain, nb); 2041 return atomic_notifier_chain_unregister(&netlink_chain, nb);
2043 } 2042 }
2044 EXPORT_SYMBOL(netlink_unregister_notifier); 2043 EXPORT_SYMBOL(netlink_unregister_notifier);
2045 2044
2046 static const struct proto_ops netlink_ops = { 2045 static const struct proto_ops netlink_ops = {
2047 .family = PF_NETLINK, 2046 .family = PF_NETLINK,
2048 .owner = THIS_MODULE, 2047 .owner = THIS_MODULE,
2049 .release = netlink_release, 2048 .release = netlink_release,
2050 .bind = netlink_bind, 2049 .bind = netlink_bind,
2051 .connect = netlink_connect, 2050 .connect = netlink_connect,
2052 .socketpair = sock_no_socketpair, 2051 .socketpair = sock_no_socketpair,
2053 .accept = sock_no_accept, 2052 .accept = sock_no_accept,
2054 .getname = netlink_getname, 2053 .getname = netlink_getname,
2055 .poll = datagram_poll, 2054 .poll = datagram_poll,
2056 .ioctl = sock_no_ioctl, 2055 .ioctl = sock_no_ioctl,
2057 .listen = sock_no_listen, 2056 .listen = sock_no_listen,
2058 .shutdown = sock_no_shutdown, 2057 .shutdown = sock_no_shutdown,
2059 .setsockopt = netlink_setsockopt, 2058 .setsockopt = netlink_setsockopt,
2060 .getsockopt = netlink_getsockopt, 2059 .getsockopt = netlink_getsockopt,
2061 .sendmsg = netlink_sendmsg, 2060 .sendmsg = netlink_sendmsg,
2062 .recvmsg = netlink_recvmsg, 2061 .recvmsg = netlink_recvmsg,
2063 .mmap = sock_no_mmap, 2062 .mmap = sock_no_mmap,
2064 .sendpage = sock_no_sendpage, 2063 .sendpage = sock_no_sendpage,
2065 }; 2064 };
2066 2065
2067 static const struct net_proto_family netlink_family_ops = { 2066 static const struct net_proto_family netlink_family_ops = {
2068 .family = PF_NETLINK, 2067 .family = PF_NETLINK,
2069 .create = netlink_create, 2068 .create = netlink_create,
2070 .owner = THIS_MODULE, /* for consistency 8) */ 2069 .owner = THIS_MODULE, /* for consistency 8) */
2071 }; 2070 };
2072 2071
2073 static int __net_init netlink_net_init(struct net *net) 2072 static int __net_init netlink_net_init(struct net *net)
2074 { 2073 {
2075 #ifdef CONFIG_PROC_FS 2074 #ifdef CONFIG_PROC_FS
2076 if (!proc_net_fops_create(net, "netlink", 0, &netlink_seq_fops)) 2075 if (!proc_net_fops_create(net, "netlink", 0, &netlink_seq_fops))
2077 return -ENOMEM; 2076 return -ENOMEM;
2078 #endif 2077 #endif
2079 return 0; 2078 return 0;
2080 } 2079 }
2081 2080
2082 static void __net_exit netlink_net_exit(struct net *net) 2081 static void __net_exit netlink_net_exit(struct net *net)
2083 { 2082 {
2084 #ifdef CONFIG_PROC_FS 2083 #ifdef CONFIG_PROC_FS
2085 proc_net_remove(net, "netlink"); 2084 proc_net_remove(net, "netlink");
2086 #endif 2085 #endif
2087 } 2086 }
2088 2087
2089 static void __init netlink_add_usersock_entry(void) 2088 static void __init netlink_add_usersock_entry(void)
2090 { 2089 {
2091 struct listeners *listeners; 2090 struct listeners *listeners;
2092 int groups = 32; 2091 int groups = 32;
2093 2092
2094 listeners = kzalloc(sizeof(*listeners) + NLGRPSZ(groups), GFP_KERNEL); 2093 listeners = kzalloc(sizeof(*listeners) + NLGRPSZ(groups), GFP_KERNEL);
2095 if (!listeners) 2094 if (!listeners)
2096 panic("netlink_add_usersock_entry: Cannot allocate listeners\n"); 2095 panic("netlink_add_usersock_entry: Cannot allocate listeners\n");
2097 2096
2098 netlink_table_grab(); 2097 netlink_table_grab();
2099 2098
2100 nl_table[NETLINK_USERSOCK].groups = groups; 2099 nl_table[NETLINK_USERSOCK].groups = groups;
2101 rcu_assign_pointer(nl_table[NETLINK_USERSOCK].listeners, listeners); 2100 rcu_assign_pointer(nl_table[NETLINK_USERSOCK].listeners, listeners);
2102 nl_table[NETLINK_USERSOCK].module = THIS_MODULE; 2101 nl_table[NETLINK_USERSOCK].module = THIS_MODULE;
2103 nl_table[NETLINK_USERSOCK].registered = 1; 2102 nl_table[NETLINK_USERSOCK].registered = 1;
2104 2103
2105 netlink_table_ungrab(); 2104 netlink_table_ungrab();
2106 } 2105 }
2107 2106
2108 static struct pernet_operations __net_initdata netlink_net_ops = { 2107 static struct pernet_operations __net_initdata netlink_net_ops = {
2109 .init = netlink_net_init, 2108 .init = netlink_net_init,
2110 .exit = netlink_net_exit, 2109 .exit = netlink_net_exit,
2111 }; 2110 };
2112 2111
2113 static int __init netlink_proto_init(void) 2112 static int __init netlink_proto_init(void)
2114 { 2113 {
2115 struct sk_buff *dummy_skb; 2114 struct sk_buff *dummy_skb;
2116 int i; 2115 int i;
2117 unsigned long limit; 2116 unsigned long limit;
2118 unsigned int order; 2117 unsigned int order;
2119 int err = proto_register(&netlink_proto, 0); 2118 int err = proto_register(&netlink_proto, 0);
2120 2119
2121 if (err != 0) 2120 if (err != 0)
2122 goto out; 2121 goto out;
2123 2122
2124 BUILD_BUG_ON(sizeof(struct netlink_skb_parms) > sizeof(dummy_skb->cb)); 2123 BUILD_BUG_ON(sizeof(struct netlink_skb_parms) > sizeof(dummy_skb->cb));
2125 2124
2126 nl_table = kcalloc(MAX_LINKS, sizeof(*nl_table), GFP_KERNEL); 2125 nl_table = kcalloc(MAX_LINKS, sizeof(*nl_table), GFP_KERNEL);
2127 if (!nl_table) 2126 if (!nl_table)
2128 goto panic; 2127 goto panic;
2129 2128
2130 if (totalram_pages >= (128 * 1024)) 2129 if (totalram_pages >= (128 * 1024))
2131 limit = totalram_pages >> (21 - PAGE_SHIFT); 2130 limit = totalram_pages >> (21 - PAGE_SHIFT);
2132 else 2131 else
2133 limit = totalram_pages >> (23 - PAGE_SHIFT); 2132 limit = totalram_pages >> (23 - PAGE_SHIFT);
2134 2133
2135 order = get_bitmask_order(limit) - 1 + PAGE_SHIFT; 2134 order = get_bitmask_order(limit) - 1 + PAGE_SHIFT;
2136 limit = (1UL << order) / sizeof(struct hlist_head); 2135 limit = (1UL << order) / sizeof(struct hlist_head);
2137 order = get_bitmask_order(min(limit, (unsigned long)UINT_MAX)) - 1; 2136 order = get_bitmask_order(min(limit, (unsigned long)UINT_MAX)) - 1;
2138 2137
2139 for (i = 0; i < MAX_LINKS; i++) { 2138 for (i = 0; i < MAX_LINKS; i++) {
2140 struct nl_pid_hash *hash = &nl_table[i].hash; 2139 struct nl_pid_hash *hash = &nl_table[i].hash;
2141 2140
2142 hash->table = nl_pid_hash_zalloc(1 * sizeof(*hash->table)); 2141 hash->table = nl_pid_hash_zalloc(1 * sizeof(*hash->table));
2143 if (!hash->table) { 2142 if (!hash->table) {
2144 while (i-- > 0) 2143 while (i-- > 0)
2145 nl_pid_hash_free(nl_table[i].hash.table, 2144 nl_pid_hash_free(nl_table[i].hash.table,
2146 1 * sizeof(*hash->table)); 2145 1 * sizeof(*hash->table));
2147 kfree(nl_table); 2146 kfree(nl_table);
2148 goto panic; 2147 goto panic;
2149 } 2148 }
2150 hash->max_shift = order; 2149 hash->max_shift = order;
2151 hash->shift = 0; 2150 hash->shift = 0;
2152 hash->mask = 0; 2151 hash->mask = 0;
2153 hash->rehash_time = jiffies; 2152 hash->rehash_time = jiffies;
2154 } 2153 }
2155 2154
2156 netlink_add_usersock_entry(); 2155 netlink_add_usersock_entry();
2157 2156
2158 sock_register(&netlink_family_ops); 2157 sock_register(&netlink_family_ops);
2159 register_pernet_subsys(&netlink_net_ops); 2158 register_pernet_subsys(&netlink_net_ops);
2160 /* The netlink device handler may be needed early. */ 2159 /* The netlink device handler may be needed early. */
2161 rtnetlink_init(); 2160 rtnetlink_init();
2162 out: 2161 out:
2163 return err; 2162 return err;
2164 panic: 2163 panic:
2165 panic("netlink_init: Cannot allocate nl_table\n"); 2164 panic("netlink_init: Cannot allocate nl_table\n");
2166 } 2165 }
2167 2166
2168 core_initcall(netlink_proto_init); 2167 core_initcall(netlink_proto_init);
2169 2168