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 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 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 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 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 197 npf_config_enter(void) 198 { 199 mutex_enter(&npf_config_lock); 200 } 201 202 void 203 npf_config_exit(void) 204 { 205 mutex_exit(&npf_config_lock); 206 } 207 208 bool 209 npf_config_locked_p(void) 210 { 211 return mutex_owned(&npf_config_lock); 212 } 213 214 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 226 npf_config_read_enter(void) 227 { 228 return pserialize_read_enter(); 229 } 230 231 void 232 npf_config_read_exit(int s) 233 { 234 pserialize_read_exit(s); 235 } 236 237 /* 238 * Accessors. 239 */ 240 241 npf_ruleset_t * 242 npf_config_ruleset(void) 243 { 244 return npf_config->n_rules; 245 } 246 247 npf_ruleset_t * 248 npf_config_natset(void) 249 { 250 return npf_config->n_nat_rules; 251 } 252 253 npf_tableset_t * 254 npf_config_tableset(void) 255 { 256 return npf_config->n_tables; 257 } 258 259 npf_rprocset_t * 260 npf_config_rprocs(void) 261 { 262 return npf_config->n_rprocs; 263 } 264 265 bool 266 npf_default_pass(void) 267 { 268 return npf_config->n_default_pass; 269 } 270