Home | History | Annotate | Line # | Download | only in npf
npf_conf.c revision 1.6
      1 /*	$NetBSD: npf_conf.c,v 1.6 2014/05/30 23:26:06 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.6 2014/05/30 23:26:06 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 
     63 typedef struct {
     64 	npf_ruleset_t *		n_rules;
     65 	npf_tableset_t *	n_tables;
     66 	npf_ruleset_t *		n_nat_rules;
     67 	npf_rprocset_t *	n_rprocs;
     68 	prop_dictionary_t	n_dict;
     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 	prop_dictionary_t dict;
     80 	npf_ruleset_t *rlset, *nset;
     81 	npf_rprocset_t *rpset;
     82 	npf_tableset_t *tset;
     83 
     84 	mutex_init(&npf_config_lock, MUTEX_DEFAULT, IPL_SOFTNET);
     85 	npf_config_psz = pserialize_create();
     86 
     87 	/* Load the empty configuration. */
     88 	dict = prop_dictionary_create();
     89 	tset = npf_tableset_create(0);
     90 	rpset = npf_rprocset_create();
     91 	rlset = npf_ruleset_create(0);
     92 	nset = npf_ruleset_create(0);
     93 	npf_config_reload(dict, rlset, tset, nset, rpset, true);
     94 	KASSERT(npf_config != NULL);
     95 }
     96 
     97 static void
     98 npf_config_destroy(npf_config_t *nc)
     99 {
    100 	prop_object_release(nc->n_dict);
    101 	npf_ruleset_destroy(nc->n_rules);
    102 	npf_ruleset_destroy(nc->n_nat_rules);
    103 	npf_rprocset_destroy(nc->n_rprocs);
    104 	npf_tableset_destroy(nc->n_tables);
    105 	kmem_free(nc, sizeof(npf_config_t));
    106 }
    107 
    108 void
    109 npf_config_fini(void)
    110 {
    111 	mutex_enter(&npf_config_lock);
    112 	pserialize_perform(npf_config_psz);
    113 	npf_ifmap_flush();
    114 	mutex_exit(&npf_config_lock);
    115 
    116 	npf_config_destroy(npf_config);
    117 	pserialize_destroy(npf_config_psz);
    118 	mutex_destroy(&npf_config_lock);
    119 }
    120 
    121 /*
    122  * npf_config_reload: the main routine performing configuration reload.
    123  * Performs the necessary synchronisation and destroys the old config.
    124  */
    125 void
    126 npf_config_reload(prop_dictionary_t dict, npf_ruleset_t *rset,
    127     npf_tableset_t *tset, npf_ruleset_t *nset, npf_rprocset_t *rpset,
    128     bool flush)
    129 {
    130 	npf_config_t *nc, *onc;
    131 
    132 	nc = kmem_zalloc(sizeof(npf_config_t), KM_SLEEP);
    133 	nc->n_rules = rset;
    134 	nc->n_tables = tset;
    135 	nc->n_nat_rules = nset;
    136 	nc->n_rprocs = rpset;
    137 	nc->n_dict = dict;
    138 	nc->n_default_pass = flush;
    139 
    140 	/*
    141 	 * Acquire the lock and perform the first phase:
    142 	 * - Scan and use existing dynamic tables, reload only static.
    143 	 * - Scan and use matching NAT policies to preserve the connections.
    144 	 */
    145 	mutex_enter(&npf_config_lock);
    146 	if ((onc = npf_config) != NULL) {
    147 		npf_ruleset_reload(rset, onc->n_rules);
    148 		npf_tableset_reload(tset, onc->n_tables);
    149 		npf_ruleset_reload(nset, onc->n_nat_rules);
    150 	}
    151 
    152 	/*
    153 	 * Set the new config and release the lock.
    154 	 */
    155 	membar_sync();
    156 	npf_config = nc;
    157 	if (onc == NULL) {
    158 		/* Initial load, done. */
    159 		npf_ifmap_flush();
    160 		mutex_exit(&npf_config_lock);
    161 		return;
    162 	}
    163 
    164 	/* Synchronise: drain all references. */
    165 	pserialize_perform(npf_config_psz);
    166 	if (flush) {
    167 		npf_ifmap_flush();
    168 	}
    169 
    170 	/* Sync the config proplib data. */
    171 	npf_tableset_syncdict(tset, dict);
    172 	mutex_exit(&npf_config_lock);
    173 
    174 	/* Finally, it is safe to destroy the old config. */
    175 	npf_config_destroy(onc);
    176 }
    177 
    178 /*
    179  * Writer-side exclusive locking.
    180  */
    181 
    182 void
    183 npf_config_enter(void)
    184 {
    185 	mutex_enter(&npf_config_lock);
    186 }
    187 
    188 void
    189 npf_config_exit(void)
    190 {
    191 	mutex_exit(&npf_config_lock);
    192 }
    193 
    194 bool
    195 npf_config_locked_p(void)
    196 {
    197 	return mutex_owned(&npf_config_lock);
    198 }
    199 
    200 void
    201 npf_config_sync(void)
    202 {
    203 	KASSERT(npf_config_locked_p());
    204 	pserialize_perform(npf_config_psz);
    205 }
    206 
    207 /*
    208  * Reader-side synchronisation routines.
    209  */
    210 
    211 int
    212 npf_config_read_enter(void)
    213 {
    214 	return pserialize_read_enter();
    215 }
    216 
    217 void
    218 npf_config_read_exit(int s)
    219 {
    220 	pserialize_read_exit(s);
    221 }
    222 
    223 /*
    224  * Accessors.
    225  */
    226 
    227 npf_ruleset_t *
    228 npf_config_ruleset(void)
    229 {
    230 	return npf_config->n_rules;
    231 }
    232 
    233 npf_ruleset_t *
    234 npf_config_natset(void)
    235 {
    236 	return npf_config->n_nat_rules;
    237 }
    238 
    239 npf_tableset_t *
    240 npf_config_tableset(void)
    241 {
    242 	return npf_config->n_tables;
    243 }
    244 
    245 prop_dictionary_t
    246 npf_config_dict(void)
    247 {
    248 	return npf_config->n_dict;
    249 }
    250 
    251 bool
    252 npf_default_pass(void)
    253 {
    254 	return npf_config->n_default_pass;
    255 }
    256