1 /* $NetBSD: npf_conf.c,v 1.9 2014/11/30 01:37:53 rmind Exp $ */
2
3 /*-
4 * Copyright (c) 2013 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This material is based upon work partially supported by The
8 * NetBSD Foundation under a contract with Mindaugas Rasiukevicius.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 /*
33 * NPF config loading mechanism.
34 *
35 * There are few main operations on the config:
36 * 1) Read access which is primarily from the npf_packet_handler() et al.
37 * 2) Write access on particular set, mainly rule or table updates.
38 * 3) Deletion of the config, which is done during the reload operation.
39 *
40 * Synchronisation
41 *
42 * For (1) case, passive serialisation is used to allow concurrent
43 * access to the configuration set (ruleset, etc). It guarantees
44 * that the config will not be destroyed while accessing it.
45 *
46 * Writers, i.e. cases (2) and (3) use mutual exclusion and when
47 * necessary writer-side barrier of the passive serialisation.
48 */
49
50 #include <sys/cdefs.h>
51 __KERNEL_RCSID(0, "$NetBSD: npf_conf.c,v 1.9 2014/11/30 01:37:53 rmind Exp $");
52
53 #include <sys/param.h>
54 #include <sys/types.h>
55
56 #include <sys/atomic.h>
57 #include <sys/kmem.h>
58 #include <sys/pserialize.h>
59 #include <sys/mutex.h>
60
61 #include "npf_impl.h"
62 #include "npf_conn.h"
63
64 typedef struct {
65 npf_ruleset_t * n_rules;
66 npf_tableset_t * n_tables;
67 npf_ruleset_t * n_nat_rules;
68 npf_rprocset_t * n_rprocs;
69 bool n_default_pass;
70 } npf_config_t;
71
72 static npf_config_t * npf_config __cacheline_aligned;
73 static kmutex_t npf_config_lock __cacheline_aligned;
74 static pserialize_t npf_config_psz __cacheline_aligned;
75
76 void
npf_config_init(void)77 npf_config_init(void)
78 {
79 npf_ruleset_t *rlset, *nset;
80 npf_rprocset_t *rpset;
81 npf_tableset_t *tset;
82
83 mutex_init(&npf_config_lock, MUTEX_DEFAULT, IPL_SOFTNET);
84 npf_config_psz = pserialize_create();
85
86 /* Load the empty configuration. */
87 tset = npf_tableset_create(0);
88 rpset = npf_rprocset_create();
89 rlset = npf_ruleset_create(0);
90 nset = npf_ruleset_create(0);
91 npf_config_load(rlset, tset, nset, rpset, NULL, true);
92 KASSERT(npf_config != NULL);
93 }
94
95 static void
npf_config_destroy(npf_config_t * nc)96 npf_config_destroy(npf_config_t *nc)
97 {
98 npf_ruleset_destroy(nc->n_rules);
99 npf_ruleset_destroy(nc->n_nat_rules);
100 npf_rprocset_destroy(nc->n_rprocs);
101 npf_tableset_destroy(nc->n_tables);
102 kmem_free(nc, sizeof(npf_config_t));
103 }
104
105 void
npf_config_fini(void)106 npf_config_fini(void)
107 {
108 npf_conndb_t *cd = npf_conndb_create();
109
110 /* Flush the connections. */
111 mutex_enter(&npf_config_lock);
112 npf_conn_tracking(false);
113 pserialize_perform(npf_config_psz);
114 npf_conn_load(cd, false);
115 npf_ifmap_flush();
116 mutex_exit(&npf_config_lock);
117
118 npf_config_destroy(npf_config);
119 pserialize_destroy(npf_config_psz);
120 mutex_destroy(&npf_config_lock);
121 }
122
123 /*
124 * npf_config_load: the main routine performing configuration load.
125 * Performs the necessary synchronisation and destroys the old config.
126 */
127 void
npf_config_load(npf_ruleset_t * rset,npf_tableset_t * tset,npf_ruleset_t * nset,npf_rprocset_t * rpset,npf_conndb_t * conns,bool flush)128 npf_config_load(npf_ruleset_t *rset, npf_tableset_t *tset,
129 npf_ruleset_t *nset, npf_rprocset_t *rpset,
130 npf_conndb_t *conns, bool flush)
131 {
132 const bool load = conns != NULL;
133 npf_config_t *nc, *onc;
134
135 nc = kmem_zalloc(sizeof(npf_config_t), KM_SLEEP);
136 nc->n_rules = rset;
137 nc->n_tables = tset;
138 nc->n_nat_rules = nset;
139 nc->n_rprocs = rpset;
140 nc->n_default_pass = flush;
141
142 /*
143 * Acquire the lock and perform the first phase:
144 * - Scan and use existing dynamic tables, reload only static.
145 * - Scan and use matching NAT policies to preserve the connections.
146 */
147 mutex_enter(&npf_config_lock);
148 if ((onc = npf_config) != NULL) {
149 npf_ruleset_reload(rset, onc->n_rules, load);
150 npf_tableset_reload(tset, onc->n_tables);
151 npf_ruleset_reload(nset, onc->n_nat_rules, load);
152 }
153
154 /*
155 * Set the new config and release the lock.
156 */
157 membar_sync();
158 npf_config = nc;
159 if (onc == NULL) {
160 /* Initial load, done. */
161 npf_ifmap_flush();
162 npf_conn_load(conns, !flush);
163 mutex_exit(&npf_config_lock);
164 return;
165 }
166
167 /*
168 * If we are going to flush the connections or load the new ones,
169 * then disable the connection tracking for the grace period.
170 */
171 if (flush || conns) {
172 npf_conn_tracking(false);
173 }
174
175 /* Synchronise: drain all references. */
176 pserialize_perform(npf_config_psz);
177 if (flush) {
178 npf_ifmap_flush();
179 }
180
181 /*
182 * G/C the existing connections and, if passed, load the new ones.
183 * If not flushing - enable the connection tracking.
184 */
185 npf_conn_load(conns, !flush);
186 mutex_exit(&npf_config_lock);
187
188 /* Finally, it is safe to destroy the old config. */
189 npf_config_destroy(onc);
190 }
191
192 /*
193 * Writer-side exclusive locking.
194 */
195
196 void
npf_config_enter(void)197 npf_config_enter(void)
198 {
199 mutex_enter(&npf_config_lock);
200 }
201
202 void
npf_config_exit(void)203 npf_config_exit(void)
204 {
205 mutex_exit(&npf_config_lock);
206 }
207
208 bool
npf_config_locked_p(void)209 npf_config_locked_p(void)
210 {
211 return mutex_owned(&npf_config_lock);
212 }
213
214 void
npf_config_sync(void)215 npf_config_sync(void)
216 {
217 KASSERT(npf_config_locked_p());
218 pserialize_perform(npf_config_psz);
219 }
220
221 /*
222 * Reader-side synchronisation routines.
223 */
224
225 int
npf_config_read_enter(void)226 npf_config_read_enter(void)
227 {
228 return pserialize_read_enter();
229 }
230
231 void
npf_config_read_exit(int s)232 npf_config_read_exit(int s)
233 {
234 pserialize_read_exit(s);
235 }
236
237 /*
238 * Accessors.
239 */
240
241 npf_ruleset_t *
npf_config_ruleset(void)242 npf_config_ruleset(void)
243 {
244 return npf_config->n_rules;
245 }
246
247 npf_ruleset_t *
npf_config_natset(void)248 npf_config_natset(void)
249 {
250 return npf_config->n_nat_rules;
251 }
252
253 npf_tableset_t *
npf_config_tableset(void)254 npf_config_tableset(void)
255 {
256 return npf_config->n_tables;
257 }
258
259 npf_rprocset_t *
npf_config_rprocs(void)260 npf_config_rprocs(void)
261 {
262 return npf_config->n_rprocs;
263 }
264
265 bool
npf_default_pass(void)266 npf_default_pass(void)
267 {
268 return npf_config->n_default_pass;
269 }
270