Return to fwsync_mod.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / fwsync / driver

remove kproc

    1: /*************************************************************************
    2: * (C) 2022 CloudSigma AG - Sofia/Bulgaria
    3: *  by Michael Pounov <misho@elwix.org>
    4: **************************************************************************/
    5: #include "fwsync.h"
    6: 
    7: 
    8: MALLOC_DEFINE(M_FWSYNC, "fwsync_memory", "FWSync - memory");
    9: 
   10: static struct ipfw_sopt_handler	soc[] = {
   11: 	{ IP_FW_SYNC_XCONFIG,	0,	HDIR_SET,	fwsync_cfg },
   12: 	{ IP_FW_SYNC_DESTROY,	0,	HDIR_SET,	fwsync_destroy },
   13: 	{ IP_FW_SYNC_XGETCONFIG,	0,	HDIR_GET,	fwsync_get_cfg },
   14: 	{ IP_FW_SYNC_LIST,	0,	HDIR_GET,	fwsync_list },
   15: 	{ IP_FW_SYNC_START,	0,	HDIR_SET,	fwsync_start },
   16: 	{ IP_FW_SYNC_STOP,	0,	HDIR_SET,	fwsync_stop },
   17: };
   18: 
   19: static volatile int fwsync_hooked = 0;
   20: struct fwsync_context fws_ctx = { 0 };
   21: int fwsync_debug = DRV_DEBUG;
   22: static struct sysctl_ctx_list fwsync_sysctl_ctx;
   23: struct cfg_sync fws_cfg;
   24: //static struct sysctl_oid *fws_sysctl_oid, *fws_sysctl_dir;
   25: 
   26: struct task fws_sndpkt_task;
   27: struct taskqueue *fws_tq;
   28: struct callout fws_co;
   29: struct mtx fws_mtx_c, fws_mtx_e;
   30: fwsync_sndpkt_t fwsync_sndpkt; 
   31: 
   32: SYSCTL_NODE(_net_inet_ip, IFT_FWSYNC, fwsync, CTLFLAG_RW, 0, "IPFW Sync - Sync firewall states");
   33: SYSCTL_INT(_net_inet_ip_fwsync, OID_AUTO, debug, CTLFLAG_RW, &fwsync_debug, 0, "Debug driver");
   34: 
   35: static int
   36: fws_fini(void *arg)
   37: {
   38: 	struct fws_sndpkt *p;
   39: 
   40: 	DTRACE();
   41: 
   42: 	if (!fwsync_hooked)
   43: 		return EBUSY;
   44: 
   45: 	if (fws_cfg.cfg.on || fws_ctx.config) {
   46: 		uprintf("Unable to unload ELWIX %s driver, cause you have active configuration.\n"
   47: 				"Before unload driver flush configuration!\n", DRV_NAME);
   48: 		return EBUSY;
   49: 	}
   50: 
   51: 	IPFW_DEL_SOPT_HANDLER(1, soc);
   52: 
   53: 	if (fws_tq)
   54: 		taskqueue_free(fws_tq);
   55: 
   56: 	mtx_lock(&fws_mtx_c);
   57: 	while (!TAILQ_EMPTY(&fwsync_sndpkt)) {
   58: 		p = TAILQ_FIRST(&fwsync_sndpkt);
   59: 		TAILQ_REMOVE(&fwsync_sndpkt, p, sp_next);
   60: 		free(p, M_FWSYNC);
   61: 	}
   62: 	mtx_unlock(&fws_mtx_c);
   63: 
   64: 	callout_drain(&fws_co);
   65: 
   66: 	mtx_destroy(&fws_mtx_c);
   67: 	mtx_destroy(&fws_mtx_e);
   68: 
   69: 	fwsync_hooked = 0;
   70: 
   71: 	/* sysctl context */
   72: 	sysctl_ctx_free(&fwsync_sysctl_ctx);
   73: 
   74: 	uprintf("Unloaded ELWIX %s driver version %d ...\n", DRV_NAME, DRV_VERSION);
   75: 	return 0;
   76: }
   77: 
   78: static int
   79: fws_shut(void *arg)
   80: {
   81: 	DTRACE();
   82: 
   83: 	fws_fini(arg);
   84: 
   85: 	return 0;
   86: }
   87: 
   88: static int
   89: fws_init(void *arg)
   90: {
   91: 	DTRACE();
   92: 
   93: 	if (fwsync_hooked)
   94: 		return 0;
   95: 
   96: 	memset(&fws_cfg, 0, sizeof fws_cfg);
   97: 	memset(&fws_ctx, 0, sizeof fws_ctx);
   98: 
   99: 	TAILQ_INIT(&fwsync_sndpkt);
  100: 
  101: 	/* mutexes */
  102: 	mtx_init(&fws_mtx_e, "fwsync mtx edge", NULL, MTX_DEF);
  103: 	mtx_init(&fws_mtx_c, "fwsync mtx collector", NULL, MTX_DEF);
  104: 
  105: 	/* taskqueue */
  106: 	TASK_INIT(&fws_sndpkt_task, 0, fwsync_sndpkt_handler, &fwsync_sndpkt);
  107: 
  108: 	fws_tq = taskqueue_create("fwsync_tq", M_NOWAIT, taskqueue_thread_enqueue, &fws_tq);
  109: 	if (!fws_tq) {
  110: 		printf("Failed to allocate fwsync task queue\n");
  111: 		mtx_destroy(&fws_mtx_c);
  112: 		mtx_destroy(&fws_mtx_e);
  113: 		return ENOMEM;
  114: 	} else
  115: 		taskqueue_start_threads(&fws_tq, 1, PI_NET, "fwsync tq");
  116: 
  117: 	/* callout */
  118: 
  119: 	callout_init_mtx(&fws_co, &fws_mtx_e, 0);
  120: 
  121: 	/* sysctl context */
  122: 	sysctl_ctx_init(&fwsync_sysctl_ctx);
  123: 
  124: 	IPFW_ADD_SOPT_HANDLER(1, soc);
  125: 
  126: 	fwsync_hooked = 1;
  127: 	uprintf("Loaded ELWIX %s driver version %d ...\n", DRV_NAME, DRV_VERSION);
  128: 	return 0;
  129: }
  130: static int
  131: fwsync_main(module_t m, int what, void *arg)
  132: {
  133: 	int ret = 0;
  134: 
  135: 	switch (what) {
  136: 		case MOD_LOAD:
  137: 			ret = fws_init(arg);
  138: 			break;
  139: 		case MOD_UNLOAD:
  140: 			ret = fws_fini(arg);
  141: 			break;
  142: 		case MOD_SHUTDOWN:
  143: 			ret = fws_shut(arg);
  144: 			break;
  145: 		case MOD_QUIESCE:
  146: 			/* don't unload driver if there have configured driver */
  147: 			if (fws_cfg.cfg.on || fws_ctx.config)
  148: 				ret = EBUSY;
  149: 			break;
  150: 		default:
  151: 			ret = EINVAL;
  152: 			break;
  153: 	}
  154: 
  155: 	return ret;
  156: }
  157: 
  158: static moduledata_t fwsync_mod = {
  159: 	"ipfw_sync",
  160: 	fwsync_main,
  161: 	NULL
  162: };
  163: 
  164: DECLARE_MODULE(ipfw_sync, fwsync_mod, SI_SUB_PROTO_FIREWALL, SI_ORDER_ANY);
  165: MODULE_DEPEND(ipfw_sync, libalias, 1, 1, 1);
  166: MODULE_DEPEND(ipfw_sync, ipfw, 3, 3, 3);
  167: MODULE_VERSION(ipfw_sync, DRV_VERSION);
  168: 
  169: SYSINIT(fws_init, SI_SUB_PROTO_FIREWALL, (SI_ORDER_ANY - 128), fws_init, NULL);
  170: SYSUNINIT(fws_fini, SI_SUB_PROTO_FIREWALL, (SI_ORDER_ANY - 128), fws_fini, NULL);