Commit | Line | Data |
---|---|---|
457c8996 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
f6ebe77f HW |
2 | #include <linux/kernel.h> |
3 | #include <linux/init.h> | |
4 | #include <linux/module.h> | |
5 | #include <linux/proc_fs.h> | |
6 | #include <linux/skbuff.h> | |
7 | #include <linux/netfilter.h> | |
bbd86b9f | 8 | #include <linux/seq_file.h> |
f6ebe77f | 9 | #include <net/protocol.h> |
f01ffbd6 | 10 | #include <net/netfilter/nf_log.h> |
f6ebe77f HW |
11 | |
12 | #include "nf_internals.h" | |
13 | ||
a5d29264 | 14 | /* Internal logging interface, which relies on the real |
f6ebe77f HW |
15 | LOG target modules */ |
16 | ||
17625274 | 17 | #define NFLOGGER_NAME_LEN 64 |
f6ebe77f | 18 | |
2851940f MK |
19 | int sysctl_nf_log_all_netns __read_mostly; |
20 | EXPORT_SYMBOL(sysctl_nf_log_all_netns); | |
21 | ||
5962815a | 22 | static struct nf_logger __rcu *loggers[NFPROTO_NUMPROTO][NF_LOG_TYPE_MAX] __read_mostly; |
9b73534d | 23 | static DEFINE_MUTEX(nf_log_mutex); |
f6ebe77f | 24 | |
0c26ed1c ML |
25 | #define nft_log_dereference(logger) \ |
26 | rcu_dereference_protected(logger, lockdep_is_held(&nf_log_mutex)) | |
27 | ||
ca735b3a | 28 | static struct nf_logger *__find_logger(int pf, const char *str_logger) |
f6ebe77f | 29 | { |
5962815a PNA |
30 | struct nf_logger *log; |
31 | int i; | |
32 | ||
33 | for (i = 0; i < NF_LOG_TYPE_MAX; i++) { | |
34 | if (loggers[pf][i] == NULL) | |
35 | continue; | |
f6ebe77f | 36 | |
0c26ed1c | 37 | log = nft_log_dereference(loggers[pf][i]); |
18082746 | 38 | if (!strncasecmp(str_logger, log->name, strlen(log->name))) |
5962815a | 39 | return log; |
ca735b3a | 40 | } |
d72367b6 | 41 | |
ca735b3a | 42 | return NULL; |
601e68e1 | 43 | } |
f6ebe77f | 44 | |
779994fa | 45 | int nf_log_set(struct net *net, u_int8_t pf, const struct nf_logger *logger) |
30e0c6a6 G |
46 | { |
47 | const struct nf_logger *log; | |
48 | ||
779994fa GF |
49 | if (pf == NFPROTO_UNSPEC || pf >= ARRAY_SIZE(net->nf.nf_loggers)) |
50 | return -EOPNOTSUPP; | |
30e0c6a6 G |
51 | |
52 | mutex_lock(&nf_log_mutex); | |
0c26ed1c | 53 | log = nft_log_dereference(net->nf.nf_loggers[pf]); |
30e0c6a6 G |
54 | if (log == NULL) |
55 | rcu_assign_pointer(net->nf.nf_loggers[pf], logger); | |
56 | ||
57 | mutex_unlock(&nf_log_mutex); | |
779994fa GF |
58 | |
59 | return 0; | |
30e0c6a6 G |
60 | } |
61 | EXPORT_SYMBOL(nf_log_set); | |
62 | ||
63 | void nf_log_unset(struct net *net, const struct nf_logger *logger) | |
64 | { | |
65 | int i; | |
66 | const struct nf_logger *log; | |
67 | ||
30e0c6a6 G |
68 | mutex_lock(&nf_log_mutex); |
69 | for (i = 0; i < NFPROTO_NUMPROTO; i++) { | |
0c26ed1c | 70 | log = nft_log_dereference(net->nf.nf_loggers[i]); |
30e0c6a6 G |
71 | if (log == logger) |
72 | RCU_INIT_POINTER(net->nf.nf_loggers[i], NULL); | |
73 | } | |
74 | mutex_unlock(&nf_log_mutex); | |
30e0c6a6 G |
75 | } |
76 | EXPORT_SYMBOL(nf_log_unset); | |
77 | ||
d93cf068 | 78 | /* return EEXIST if the same logger is registered, 0 on success. */ |
ca735b3a | 79 | int nf_log_register(u_int8_t pf, struct nf_logger *logger) |
f6ebe77f | 80 | { |
b6f0a365 | 81 | int i; |
8ac2bde2 | 82 | int ret = 0; |
ca735b3a | 83 | |
30e0c6a6 | 84 | if (pf >= ARRAY_SIZE(init_net.nf.nf_loggers)) |
ca735b3a EL |
85 | return -EINVAL; |
86 | ||
9b73534d | 87 | mutex_lock(&nf_log_mutex); |
ca735b3a EL |
88 | |
89 | if (pf == NFPROTO_UNSPEC) { | |
8ac2bde2 ML |
90 | for (i = NFPROTO_UNSPEC; i < NFPROTO_NUMPROTO; i++) { |
91 | if (rcu_access_pointer(loggers[i][logger->type])) { | |
92 | ret = -EEXIST; | |
93 | goto unlock; | |
94 | } | |
95 | } | |
ca735b3a | 96 | for (i = NFPROTO_UNSPEC; i < NFPROTO_NUMPROTO; i++) |
5962815a | 97 | rcu_assign_pointer(loggers[i][logger->type], logger); |
ca735b3a | 98 | } else { |
8ac2bde2 ML |
99 | if (rcu_access_pointer(loggers[pf][logger->type])) { |
100 | ret = -EEXIST; | |
101 | goto unlock; | |
102 | } | |
5962815a | 103 | rcu_assign_pointer(loggers[pf][logger->type], logger); |
ca735b3a EL |
104 | } |
105 | ||
8ac2bde2 | 106 | unlock: |
9b73534d | 107 | mutex_unlock(&nf_log_mutex); |
8ac2bde2 | 108 | return ret; |
f6ebe77f | 109 | } |
ca735b3a | 110 | EXPORT_SYMBOL(nf_log_register); |
f6ebe77f | 111 | |
ca735b3a | 112 | void nf_log_unregister(struct nf_logger *logger) |
f6ebe77f | 113 | { |
205ee117 | 114 | const struct nf_logger *log; |
f6ebe77f HW |
115 | int i; |
116 | ||
9b73534d | 117 | mutex_lock(&nf_log_mutex); |
205ee117 FW |
118 | for (i = 0; i < NFPROTO_NUMPROTO; i++) { |
119 | log = nft_log_dereference(loggers[i][logger->type]); | |
120 | if (log == logger) | |
121 | RCU_INIT_POINTER(loggers[i][logger->type], NULL); | |
122 | } | |
9b73534d | 123 | mutex_unlock(&nf_log_mutex); |
ad5001cc | 124 | synchronize_rcu(); |
f6ebe77f | 125 | } |
e92ad99c | 126 | EXPORT_SYMBOL(nf_log_unregister); |
f6ebe77f | 127 | |
30e0c6a6 G |
128 | int nf_log_bind_pf(struct net *net, u_int8_t pf, |
129 | const struct nf_logger *logger) | |
ca735b3a | 130 | { |
30e0c6a6 | 131 | if (pf >= ARRAY_SIZE(net->nf.nf_loggers)) |
9ef0298a | 132 | return -EINVAL; |
ca735b3a EL |
133 | mutex_lock(&nf_log_mutex); |
134 | if (__find_logger(pf, logger->name) == NULL) { | |
135 | mutex_unlock(&nf_log_mutex); | |
136 | return -ENOENT; | |
137 | } | |
30e0c6a6 | 138 | rcu_assign_pointer(net->nf.nf_loggers[pf], logger); |
ca735b3a EL |
139 | mutex_unlock(&nf_log_mutex); |
140 | return 0; | |
141 | } | |
142 | EXPORT_SYMBOL(nf_log_bind_pf); | |
143 | ||
30e0c6a6 | 144 | void nf_log_unbind_pf(struct net *net, u_int8_t pf) |
ca735b3a | 145 | { |
30e0c6a6 | 146 | if (pf >= ARRAY_SIZE(net->nf.nf_loggers)) |
9ef0298a | 147 | return; |
ca735b3a | 148 | mutex_lock(&nf_log_mutex); |
30e0c6a6 | 149 | RCU_INIT_POINTER(net->nf.nf_loggers[pf], NULL); |
ca735b3a EL |
150 | mutex_unlock(&nf_log_mutex); |
151 | } | |
152 | EXPORT_SYMBOL(nf_log_unbind_pf); | |
153 | ||
960649d1 PNA |
154 | void nf_logger_request_module(int pf, enum nf_log_type type) |
155 | { | |
156 | if (loggers[pf][type] == NULL) | |
157 | request_module("nf-logger-%u-%u", pf, type); | |
158 | } | |
159 | EXPORT_SYMBOL_GPL(nf_logger_request_module); | |
160 | ||
fab4085f PNA |
161 | int nf_logger_find_get(int pf, enum nf_log_type type) |
162 | { | |
163 | struct nf_logger *logger; | |
164 | int ret = -ENOENT; | |
165 | ||
f3bb5333 LZ |
166 | if (pf == NFPROTO_INET) { |
167 | ret = nf_logger_find_get(NFPROTO_IPV4, type); | |
168 | if (ret < 0) | |
169 | return ret; | |
170 | ||
171 | ret = nf_logger_find_get(NFPROTO_IPV6, type); | |
172 | if (ret < 0) { | |
173 | nf_logger_put(NFPROTO_IPV4, type); | |
174 | return ret; | |
175 | } | |
176 | ||
177 | return 0; | |
178 | } | |
179 | ||
c5a589cc | 180 | if (rcu_access_pointer(loggers[pf][type]) == NULL) |
fab4085f PNA |
181 | request_module("nf-logger-%u-%u", pf, type); |
182 | ||
183 | rcu_read_lock(); | |
184 | logger = rcu_dereference(loggers[pf][type]); | |
185 | if (logger == NULL) | |
186 | goto out; | |
187 | ||
7e53e7f8 | 188 | if (try_module_get(logger->me)) |
fab4085f PNA |
189 | ret = 0; |
190 | out: | |
191 | rcu_read_unlock(); | |
192 | return ret; | |
193 | } | |
194 | EXPORT_SYMBOL_GPL(nf_logger_find_get); | |
195 | ||
196 | void nf_logger_put(int pf, enum nf_log_type type) | |
197 | { | |
198 | struct nf_logger *logger; | |
199 | ||
f3bb5333 LZ |
200 | if (pf == NFPROTO_INET) { |
201 | nf_logger_put(NFPROTO_IPV4, type); | |
202 | nf_logger_put(NFPROTO_IPV6, type); | |
203 | return; | |
204 | } | |
205 | ||
fab4085f PNA |
206 | BUG_ON(loggers[pf][type] == NULL); |
207 | ||
208 | rcu_read_lock(); | |
209 | logger = rcu_dereference(loggers[pf][type]); | |
210 | module_put(logger->me); | |
211 | rcu_read_unlock(); | |
212 | } | |
213 | EXPORT_SYMBOL_GPL(nf_logger_put); | |
214 | ||
30e0c6a6 G |
215 | void nf_log_packet(struct net *net, |
216 | u_int8_t pf, | |
f6ebe77f HW |
217 | unsigned int hooknum, |
218 | const struct sk_buff *skb, | |
219 | const struct net_device *in, | |
220 | const struct net_device *out, | |
7b2f9631 | 221 | const struct nf_loginfo *loginfo, |
f6ebe77f HW |
222 | const char *fmt, ...) |
223 | { | |
224 | va_list args; | |
225 | char prefix[NF_LOG_PREFIXLEN]; | |
7b2f9631 | 226 | const struct nf_logger *logger; |
601e68e1 | 227 | |
f6ebe77f | 228 | rcu_read_lock(); |
fab4085f PNA |
229 | if (loginfo != NULL) |
230 | logger = rcu_dereference(loggers[pf][loginfo->type]); | |
231 | else | |
232 | logger = rcu_dereference(net->nf.nf_loggers[pf]); | |
233 | ||
f6ebe77f HW |
234 | if (logger) { |
235 | va_start(args, fmt); | |
236 | vsnprintf(prefix, sizeof(prefix), fmt, args); | |
237 | va_end(args); | |
8cdb46da | 238 | logger->logfn(net, pf, hooknum, skb, in, out, loginfo, prefix); |
f6ebe77f HW |
239 | } |
240 | rcu_read_unlock(); | |
241 | } | |
242 | EXPORT_SYMBOL(nf_log_packet); | |
243 | ||
4017a7ee PNA |
244 | void nf_log_trace(struct net *net, |
245 | u_int8_t pf, | |
246 | unsigned int hooknum, | |
247 | const struct sk_buff *skb, | |
248 | const struct net_device *in, | |
249 | const struct net_device *out, | |
250 | const struct nf_loginfo *loginfo, const char *fmt, ...) | |
251 | { | |
252 | va_list args; | |
253 | char prefix[NF_LOG_PREFIXLEN]; | |
254 | const struct nf_logger *logger; | |
255 | ||
256 | rcu_read_lock(); | |
257 | logger = rcu_dereference(net->nf.nf_loggers[pf]); | |
258 | if (logger) { | |
259 | va_start(args, fmt); | |
260 | vsnprintf(prefix, sizeof(prefix), fmt, args); | |
261 | va_end(args); | |
262 | logger->logfn(net, pf, hooknum, skb, in, out, loginfo, prefix); | |
263 | } | |
264 | rcu_read_unlock(); | |
265 | } | |
266 | EXPORT_SYMBOL(nf_log_trace); | |
267 | ||
27fd8d90 PNA |
268 | #define S_SIZE (1024 - (sizeof(unsigned int) + 1)) |
269 | ||
270 | struct nf_log_buf { | |
271 | unsigned int count; | |
272 | char buf[S_SIZE + 1]; | |
273 | }; | |
274 | static struct nf_log_buf emergency, *emergency_ptr = &emergency; | |
275 | ||
276 | __printf(2, 3) int nf_log_buf_add(struct nf_log_buf *m, const char *f, ...) | |
277 | { | |
278 | va_list args; | |
279 | int len; | |
280 | ||
281 | if (likely(m->count < S_SIZE)) { | |
282 | va_start(args, f); | |
283 | len = vsnprintf(m->buf + m->count, S_SIZE - m->count, f, args); | |
284 | va_end(args); | |
285 | if (likely(m->count + len < S_SIZE)) { | |
286 | m->count += len; | |
287 | return 0; | |
288 | } | |
289 | } | |
290 | m->count = S_SIZE; | |
291 | printk_once(KERN_ERR KBUILD_MODNAME " please increase S_SIZE\n"); | |
292 | return -1; | |
293 | } | |
294 | EXPORT_SYMBOL_GPL(nf_log_buf_add); | |
295 | ||
296 | struct nf_log_buf *nf_log_buf_open(void) | |
297 | { | |
298 | struct nf_log_buf *m = kmalloc(sizeof(*m), GFP_ATOMIC); | |
299 | ||
300 | if (unlikely(!m)) { | |
301 | local_bh_disable(); | |
302 | do { | |
303 | m = xchg(&emergency_ptr, NULL); | |
304 | } while (!m); | |
305 | } | |
306 | m->count = 0; | |
307 | return m; | |
308 | } | |
309 | EXPORT_SYMBOL_GPL(nf_log_buf_open); | |
310 | ||
311 | void nf_log_buf_close(struct nf_log_buf *m) | |
312 | { | |
313 | m->buf[m->count] = 0; | |
314 | printk("%s\n", m->buf); | |
315 | ||
316 | if (likely(m != &emergency)) | |
317 | kfree(m); | |
318 | else { | |
319 | emergency_ptr = m; | |
320 | local_bh_enable(); | |
321 | } | |
322 | } | |
323 | EXPORT_SYMBOL_GPL(nf_log_buf_close); | |
324 | ||
f6ebe77f HW |
325 | #ifdef CONFIG_PROC_FS |
326 | static void *seq_start(struct seq_file *seq, loff_t *pos) | |
327 | { | |
30e0c6a6 G |
328 | struct net *net = seq_file_net(seq); |
329 | ||
6440fe05 | 330 | mutex_lock(&nf_log_mutex); |
f6ebe77f | 331 | |
30e0c6a6 | 332 | if (*pos >= ARRAY_SIZE(net->nf.nf_loggers)) |
f6ebe77f HW |
333 | return NULL; |
334 | ||
335 | return pos; | |
336 | } | |
337 | ||
338 | static void *seq_next(struct seq_file *s, void *v, loff_t *pos) | |
339 | { | |
30e0c6a6 G |
340 | struct net *net = seq_file_net(s); |
341 | ||
f6ebe77f HW |
342 | (*pos)++; |
343 | ||
30e0c6a6 | 344 | if (*pos >= ARRAY_SIZE(net->nf.nf_loggers)) |
f6ebe77f HW |
345 | return NULL; |
346 | ||
347 | return pos; | |
348 | } | |
349 | ||
350 | static void seq_stop(struct seq_file *s, void *v) | |
351 | { | |
6440fe05 | 352 | mutex_unlock(&nf_log_mutex); |
f6ebe77f HW |
353 | } |
354 | ||
355 | static int seq_show(struct seq_file *s, void *v) | |
356 | { | |
357 | loff_t *pos = v; | |
358 | const struct nf_logger *logger; | |
e71456ae | 359 | int i; |
30e0c6a6 | 360 | struct net *net = seq_file_net(s); |
f6ebe77f | 361 | |
0c26ed1c | 362 | logger = nft_log_dereference(net->nf.nf_loggers[*pos]); |
f6ebe77f HW |
363 | |
364 | if (!logger) | |
e71456ae | 365 | seq_printf(s, "%2lld NONE (", *pos); |
c7a913cd | 366 | else |
e71456ae | 367 | seq_printf(s, "%2lld %s (", *pos, logger->name); |
c7a913cd | 368 | |
e71456ae SRRH |
369 | if (seq_has_overflowed(s)) |
370 | return -ENOSPC; | |
c7a913cd | 371 | |
5962815a PNA |
372 | for (i = 0; i < NF_LOG_TYPE_MAX; i++) { |
373 | if (loggers[*pos][i] == NULL) | |
374 | continue; | |
375 | ||
0c26ed1c | 376 | logger = nft_log_dereference(loggers[*pos][i]); |
eca27f14 | 377 | seq_puts(s, logger->name); |
e71456ae | 378 | if (i == 0 && loggers[*pos][i + 1] != NULL) |
cdec2685 | 379 | seq_puts(s, ","); |
e71456ae SRRH |
380 | |
381 | if (seq_has_overflowed(s)) | |
382 | return -ENOSPC; | |
c7a913cd | 383 | } |
601e68e1 | 384 | |
cdec2685 | 385 | seq_puts(s, ")\n"); |
e71456ae SRRH |
386 | |
387 | if (seq_has_overflowed(s)) | |
388 | return -ENOSPC; | |
389 | return 0; | |
f6ebe77f HW |
390 | } |
391 | ||
56b3d975 | 392 | static const struct seq_operations nflog_seq_ops = { |
f6ebe77f HW |
393 | .start = seq_start, |
394 | .next = seq_next, | |
395 | .stop = seq_stop, | |
396 | .show = seq_show, | |
397 | }; | |
f6ebe77f HW |
398 | #endif /* PROC_FS */ |
399 | ||
17625274 | 400 | #ifdef CONFIG_SYSCTL |
17625274 EL |
401 | static char nf_log_sysctl_fnames[NFPROTO_NUMPROTO-NFPROTO_UNSPEC][3]; |
402 | static struct ctl_table nf_log_sysctl_table[NFPROTO_NUMPROTO+1]; | |
2851940f MK |
403 | static struct ctl_table_header *nf_log_sysctl_fhdr; |
404 | ||
405 | static struct ctl_table nf_log_sysctl_ftable[] = { | |
406 | { | |
407 | .procname = "nf_log_all_netns", | |
408 | .data = &sysctl_nf_log_all_netns, | |
409 | .maxlen = sizeof(sysctl_nf_log_all_netns), | |
410 | .mode = 0644, | |
411 | .proc_handler = proc_dointvec, | |
412 | }, | |
413 | { } | |
414 | }; | |
f6ebe77f | 415 | |
fe2c6338 | 416 | static int nf_log_proc_dostring(struct ctl_table *table, int write, |
24955619 | 417 | void __user *buffer, size_t *lenp, loff_t *ppos) |
17625274 EL |
418 | { |
419 | const struct nf_logger *logger; | |
24955619 | 420 | char buf[NFLOGGER_NAME_LEN]; |
17625274 EL |
421 | int r = 0; |
422 | int tindex = (unsigned long)table->extra1; | |
dbb5918c | 423 | struct net *net = table->extra2; |
17625274 EL |
424 | |
425 | if (write) { | |
c6ac37d8 PT |
426 | struct ctl_table tmp = *table; |
427 | ||
dffd22ae JH |
428 | /* proc_dostring() can append to existing strings, so we need to |
429 | * initialize it as an empty string. | |
430 | */ | |
431 | buf[0] = '\0'; | |
c6ac37d8 PT |
432 | tmp.data = buf; |
433 | r = proc_dostring(&tmp, write, buffer, lenp, ppos); | |
434 | if (r) | |
435 | return r; | |
24955619 PM |
436 | |
437 | if (!strcmp(buf, "NONE")) { | |
30e0c6a6 | 438 | nf_log_unbind_pf(net, tindex); |
17625274 EL |
439 | return 0; |
440 | } | |
441 | mutex_lock(&nf_log_mutex); | |
24955619 | 442 | logger = __find_logger(tindex, buf); |
17625274 EL |
443 | if (logger == NULL) { |
444 | mutex_unlock(&nf_log_mutex); | |
445 | return -ENOENT; | |
446 | } | |
30e0c6a6 | 447 | rcu_assign_pointer(net->nf.nf_loggers[tindex], logger); |
17625274 EL |
448 | mutex_unlock(&nf_log_mutex); |
449 | } else { | |
ce00bf07 JH |
450 | struct ctl_table tmp = *table; |
451 | ||
452 | tmp.data = buf; | |
266d07cb | 453 | mutex_lock(&nf_log_mutex); |
0c26ed1c | 454 | logger = nft_log_dereference(net->nf.nf_loggers[tindex]); |
17625274 | 455 | if (!logger) |
ce00bf07 | 456 | strlcpy(buf, "NONE", sizeof(buf)); |
17625274 | 457 | else |
ce00bf07 | 458 | strlcpy(buf, logger->name, sizeof(buf)); |
266d07cb | 459 | mutex_unlock(&nf_log_mutex); |
ce00bf07 | 460 | r = proc_dostring(&tmp, write, buffer, lenp, ppos); |
17625274 EL |
461 | } |
462 | ||
463 | return r; | |
464 | } | |
465 | ||
30e0c6a6 | 466 | static int netfilter_log_sysctl_init(struct net *net) |
f6ebe77f | 467 | { |
ca735b3a | 468 | int i; |
30e0c6a6 G |
469 | struct ctl_table *table; |
470 | ||
471 | table = nf_log_sysctl_table; | |
472 | if (!net_eq(net, &init_net)) { | |
473 | table = kmemdup(nf_log_sysctl_table, | |
474 | sizeof(nf_log_sysctl_table), | |
475 | GFP_KERNEL); | |
476 | if (!table) | |
477 | goto err_alloc; | |
478 | } else { | |
479 | for (i = NFPROTO_UNSPEC; i < NFPROTO_NUMPROTO; i++) { | |
480 | snprintf(nf_log_sysctl_fnames[i], | |
481 | 3, "%d", i); | |
482 | nf_log_sysctl_table[i].procname = | |
483 | nf_log_sysctl_fnames[i]; | |
8aefc4d1 | 484 | nf_log_sysctl_table[i].maxlen = NFLOGGER_NAME_LEN; |
30e0c6a6 G |
485 | nf_log_sysctl_table[i].mode = 0644; |
486 | nf_log_sysctl_table[i].proc_handler = | |
487 | nf_log_proc_dostring; | |
488 | nf_log_sysctl_table[i].extra1 = | |
489 | (void *)(unsigned long) i; | |
490 | } | |
2851940f MK |
491 | nf_log_sysctl_fhdr = register_net_sysctl(net, "net/netfilter", |
492 | nf_log_sysctl_ftable); | |
493 | if (!nf_log_sysctl_fhdr) | |
494 | goto err_freg; | |
17625274 EL |
495 | } |
496 | ||
dbb5918c JH |
497 | for (i = NFPROTO_UNSPEC; i < NFPROTO_NUMPROTO; i++) |
498 | table[i].extra2 = net; | |
499 | ||
30e0c6a6 G |
500 | net->nf.nf_log_dir_header = register_net_sysctl(net, |
501 | "net/netfilter/nf_log", | |
502 | table); | |
503 | if (!net->nf.nf_log_dir_header) | |
504 | goto err_reg; | |
17625274 EL |
505 | |
506 | return 0; | |
30e0c6a6 G |
507 | |
508 | err_reg: | |
509 | if (!net_eq(net, &init_net)) | |
510 | kfree(table); | |
2851940f MK |
511 | else |
512 | unregister_net_sysctl_table(nf_log_sysctl_fhdr); | |
513 | err_freg: | |
30e0c6a6 G |
514 | err_alloc: |
515 | return -ENOMEM; | |
516 | } | |
517 | ||
518 | static void netfilter_log_sysctl_exit(struct net *net) | |
519 | { | |
520 | struct ctl_table *table; | |
521 | ||
522 | table = net->nf.nf_log_dir_header->ctl_table_arg; | |
523 | unregister_net_sysctl_table(net->nf.nf_log_dir_header); | |
524 | if (!net_eq(net, &init_net)) | |
525 | kfree(table); | |
2851940f MK |
526 | else |
527 | unregister_net_sysctl_table(nf_log_sysctl_fhdr); | |
17625274 EL |
528 | } |
529 | #else | |
30e0c6a6 | 530 | static int netfilter_log_sysctl_init(struct net *net) |
17625274 EL |
531 | { |
532 | return 0; | |
533 | } | |
30e0c6a6 G |
534 | |
535 | static void netfilter_log_sysctl_exit(struct net *net) | |
536 | { | |
537 | } | |
17625274 EL |
538 | #endif /* CONFIG_SYSCTL */ |
539 | ||
30e0c6a6 | 540 | static int __net_init nf_log_net_init(struct net *net) |
17625274 | 541 | { |
30e0c6a6 G |
542 | int ret = -ENOMEM; |
543 | ||
f6ebe77f | 544 | #ifdef CONFIG_PROC_FS |
c3506372 CH |
545 | if (!proc_create_net("nf_log", 0444, net->nf.proc_netfilter, |
546 | &nflog_seq_ops, sizeof(struct seq_net_private))) | |
30e0c6a6 | 547 | return ret; |
62243927 | 548 | #endif |
30e0c6a6 G |
549 | ret = netfilter_log_sysctl_init(net); |
550 | if (ret < 0) | |
551 | goto out_sysctl; | |
ca735b3a | 552 | |
30e0c6a6 G |
553 | return 0; |
554 | ||
555 | out_sysctl: | |
e778f56e | 556 | #ifdef CONFIG_PROC_FS |
6d11cfdb | 557 | remove_proc_entry("nf_log", net->nf.proc_netfilter); |
e778f56e | 558 | #endif |
30e0c6a6 G |
559 | return ret; |
560 | } | |
561 | ||
562 | static void __net_exit nf_log_net_exit(struct net *net) | |
563 | { | |
564 | netfilter_log_sysctl_exit(net); | |
e778f56e | 565 | #ifdef CONFIG_PROC_FS |
30e0c6a6 | 566 | remove_proc_entry("nf_log", net->nf.proc_netfilter); |
e778f56e | 567 | #endif |
30e0c6a6 G |
568 | } |
569 | ||
570 | static struct pernet_operations nf_log_net_ops = { | |
571 | .init = nf_log_net_init, | |
572 | .exit = nf_log_net_exit, | |
573 | }; | |
574 | ||
575 | int __init netfilter_log_init(void) | |
576 | { | |
5962815a | 577 | return register_pernet_subsys(&nf_log_net_ops); |
f6ebe77f | 578 | } |