/*- * Copyright (c) 2010 Lawrence Stewart * Copyright (c) 2010 The FreeBSD Foundation * All rights reserved. * * This software was developed by Lawrence Stewart while studying at the Centre * for Advanced Internet Architectures, Swinburne University of Technology, * made possible in part by grants from the FreeBSD Foundation and Cisco * University Research Program Fund at Community Foundation Silicon Valley. * * Portions of this software were developed at the Centre for Advanced * Internet Architectures, Swinburne University of Technology, Melbourne, * Australia by Lawrence Stewart under sponsorship from the FreeBSD Foundation. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include static struct rwlock khelp_list_lock; RW_SYSINIT(khelplistlock, &khelp_list_lock, "helper list lock"); static TAILQ_HEAD(helper_head, helper) helpers = TAILQ_HEAD_INITIALIZER(helpers); /* Private function prototypes. */ static inline void khelp_remove_osd(struct helper *h, struct osd *hosd); #define KHELP_LIST_WLOCK() rw_wlock(&khelp_list_lock) #define KHELP_LIST_WUNLOCK() rw_wunlock(&khelp_list_lock) #define KHELP_LIST_RLOCK() rw_rlock(&khelp_list_lock) #define KHELP_LIST_RUNLOCK() rw_runlock(&khelp_list_lock) #define KHELP_LIST_LOCK_ASSERT() rw_assert(&khelp_list_lock, RA_LOCKED) int khelp_register_helper(struct helper *h) { struct helper *tmph; int error, i, inserted; error = 0; inserted = 0; refcount_init(&h->h_refcount, 0); h->h_id = osd_register(OSD_KHELP, NULL, NULL); /* It's only safe to add the hooks after osd_register(). */ if (h->h_nhooks > 0) { for (i = 0; i < h->h_nhooks && !error; i++) { /* We don't require the module to assign hook_helper. */ h->h_hooks[i].hook_helper = h; error = khelp_add_hhook(&h->h_hooks[i], HHOOK_NOWAIT); } if (error) { for (i--; i >= 0; i--) khelp_remove_hhook(&h->h_hooks[i]); osd_deregister(OSD_KHELP, h->h_id); } } if (!error) { KHELP_LIST_WLOCK(); /* * Keep list of helpers sorted in descending h_id order. Due to * the way osd_set() works, a sorted list ensures * init_helper_osd() will operate with improved efficiency. */ TAILQ_FOREACH(tmph, &helpers, h_next) { if (tmph->h_id < h->h_id) { TAILQ_INSERT_BEFORE(tmph, h, h_next); inserted = 1; break; } } if (!inserted) TAILQ_INSERT_TAIL(&helpers, h, h_next); KHELP_LIST_WUNLOCK(); } return (error); } int khelp_deregister_helper(struct helper *h) { struct helper *tmph; int error, i; error = 0; KHELP_LIST_WLOCK(); if (h->h_refcount > 0) error = EBUSY; else { error = ENOENT; TAILQ_FOREACH(tmph, &helpers, h_next) { if (tmph == h) { TAILQ_REMOVE(&helpers, h, h_next); error = 0; break; } } } KHELP_LIST_WUNLOCK(); if (!error) { if (h->h_nhooks > 0) { for (i = 0; i < h->h_nhooks; i++) khelp_remove_hhook(&h->h_hooks[i]); } osd_deregister(OSD_KHELP, h->h_id); } return (error); } int khelp_init_osd(uint32_t classes, struct osd *hosd) { struct helper *h; void *hdata; int error; KASSERT(hosd != NULL, ("struct osd not initialised!")); error = 0; KHELP_LIST_RLOCK(); TAILQ_FOREACH(h, &helpers, h_next) { /* If helper is correct class and needs to store OSD... */ if (h->h_classes & classes && h->h_flags & HELPER_NEEDS_OSD) { hdata = uma_zalloc(h->h_zone, M_NOWAIT); if (hdata == NULL) { error = ENOMEM; break; } osd_set(OSD_KHELP, hosd, h->h_id, hdata); refcount_acquire(&h->h_refcount); } } if (error) { /* Delete OSD that was assigned prior to the error. */ TAILQ_FOREACH(h, &helpers, h_next) { if (h->h_classes & classes) khelp_remove_osd(h, hosd); } } KHELP_LIST_RUNLOCK(); return (error); } int khelp_destroy_osd(struct osd *hosd) { struct helper *h; int error; KASSERT(hosd != NULL, ("struct osd not initialised!")); error = 0; KHELP_LIST_RLOCK(); /* * Clean up all khelp related OSD. * * XXXLAS: Would be nice to use something like osd_exit() here but it * doesn't have the right semantics for this purpose. */ TAILQ_FOREACH(h, &helpers, h_next) khelp_remove_osd(h, hosd); KHELP_LIST_RUNLOCK(); return (error); } static inline void khelp_remove_osd(struct helper *h, struct osd *hosd) { void *hdata; if (h->h_flags & HELPER_NEEDS_OSD) { /* * If the current helper uses OSD and calling osd_get() * on the helper's h_id returns non-NULL, the helper has * OSD attached to 'hosd' which needs to be cleaned up. */ hdata = osd_get(OSD_KHELP, hosd, h->h_id); if (hdata != NULL) { uma_zfree(h->h_zone, hdata); osd_del(OSD_KHELP, hosd, h->h_id); refcount_release(&h->h_refcount); } } } void * khelp_get_osd(struct osd *hosd, int32_t id) { return (osd_get(OSD_KHELP, hosd, id)); } int32_t khelp_get_id(char *hname) { struct helper *h; int32_t id; id = -1; KHELP_LIST_RLOCK(); TAILQ_FOREACH(h, &helpers, h_next) { if (strncmp(h->h_name, hname, HELPER_NAME_MAXLEN) == 0) { id = h->h_id; break; } } KHELP_LIST_RUNLOCK(); return (id); } int khelp_add_hhook(struct hookinfo *hki, uint32_t flags) { VNET_ITERATOR_DECL(vnet_iter); int error; error = 0; /* * XXXLAS: If a helper is dynamically adding a helper hook function at * runtime using this function, we should update the helper's h_hooks * struct member to include the additional hookinfo struct. */ VNET_LIST_RLOCK_NOSLEEP(); VNET_FOREACH(vnet_iter) { CURVNET_SET(vnet_iter); error = hhook_add_hook_lookup(hki, flags); CURVNET_RESTORE(); #ifdef VIMAGE if (error) break; #endif } VNET_LIST_RUNLOCK_NOSLEEP(); return (error); } int khelp_remove_hhook(struct hookinfo *hki) { VNET_ITERATOR_DECL(vnet_iter); int error; error = 0; /* * XXXLAS: If a helper is dynamically removing a helper hook function at * runtime using this function, we should update the helper's h_hooks * struct member to remove the defunct hookinfo struct. */ VNET_LIST_RLOCK_NOSLEEP(); VNET_FOREACH(vnet_iter) { CURVNET_SET(vnet_iter); error = hhook_remove_hook_lookup(hki); CURVNET_RESTORE(); #ifdef VIMAGE if (error) break; #endif } VNET_LIST_RUNLOCK_NOSLEEP(); return (error); } int khelp_modevent(module_t mod, int event_type, void *data) { struct khelp_modevent_data *kmd; int error; kmd = (struct khelp_modevent_data *)data; error = 0; switch(event_type) { case MOD_LOAD: if (kmd->helper->h_flags & HELPER_NEEDS_OSD) { if (kmd->uma_zsize <= 0) { printf("Use KHELP_DECLARE_MOD_UMA() instead!\n"); error = EDOOFUS; break; } kmd->helper->h_zone = uma_zcreate(kmd->name, kmd->uma_zsize, kmd->umactor, kmd->umadtor, NULL, NULL, 0, 0); if (kmd->helper->h_zone == NULL) { error = ENOMEM; break; } } strlcpy(kmd->helper->h_name, kmd->name, HELPER_NAME_MAXLEN); kmd->helper->h_hooks = kmd->hooks; kmd->helper->h_nhooks = kmd->nhooks; if (kmd->helper->mod_init != NULL) error = kmd->helper->mod_init(); if (!error) error = khelp_register_helper(kmd->helper); break; case MOD_QUIESCE: case MOD_SHUTDOWN: case MOD_UNLOAD: error = khelp_deregister_helper(kmd->helper); if (!error) { if (kmd->helper->h_flags & HELPER_NEEDS_OSD) uma_zdestroy(kmd->helper->h_zone); if (kmd->helper->mod_destroy != NULL) kmd->helper->mod_destroy(); } else if (error == ENOENT) /* Do nothing and allow unload if helper not in list. */ error = 0; else if (error == EBUSY) printf("Khelp module \"%s\" can't unload until its " "refcount drops from %d to 0.\n", kmd->name, kmd->helper->h_refcount); break; default: error = EINVAL; break; } return (error); } /* * This function is called in two separate situations: * * - When the kernel is booting, it is called directly by the SYSINIT framework * to allow Khelp modules which were compiled into the kernel or loaded by the * boot loader to insert their non-virtualised hook functions into the kernel. * * - When the kernel is booting or a vnet is created, this function is also * called indirectly through khelp_vnet_init() by the vnet initialisation code. * In this situation, Khelp modules are able to insert their virtualised hook * functions into the virtualised hook points in the vnet which is being * initialised. In the case where the kernel is not compiled with "options * VIMAGE", this step is still run once at boot, but the hook functions get * transparently inserted into the standard unvirtualised network stack. */ static void khelp_init(const void *vnet) { struct helper *h; int error, i, vinit; int32_t htype, hid; error = 0; vinit = vnet != NULL; KHELP_LIST_RLOCK(); TAILQ_FOREACH(h, &helpers, h_next) { for (i = 0; i < h->h_nhooks && !error; i++) { htype = h->h_hooks[i].hook_type; hid = h->h_hooks[i].hook_id; /* * If we're doing a virtualised init (vinit != 0) and * the hook point is virtualised, or we're doing a plain * sysinit at boot and the hook point is not * virtualised, insert the hook. */ if ((hhook_head_is_virtualised_lookup(htype, hid) == HHOOK_HEADISINVNET && vinit) || (!hhook_head_is_virtualised_lookup(htype, hid) && !vinit)) { error = hhook_add_hook_lookup(&h->h_hooks[i], HHOOK_NOWAIT); } } if (error) { /* Remove any helper's hooks we successfully added. */ for (i--; i >= 0; i--) hhook_remove_hook_lookup(&h->h_hooks[i]); printf("%s: Failed to add hooks for helper \"%s\" (%p)", __func__, h->h_name, h); if (vinit) printf(" to vnet %p.\n", vnet); else printf(".\n"); error = 0; } } KHELP_LIST_RUNLOCK(); } /* * Vnet created and being initialised. */ static void khelp_vnet_init(const void *unused __unused) { khelp_init(TD_TO_VNET(curthread)); } /* * As the kernel boots, allow Khelp modules which were compiled into the kernel * or loaded by the boot loader to insert their non-virtualised hook functions * into the kernel. */ SYSINIT(khelp_init, SI_SUB_PROTO_END, SI_ORDER_FIRST, khelp_init, NULL); /* * When a vnet is created and being initialised, we need to insert the helper * hook functions for all currently registered Khelp modules into the vnet's * helper hook points. The hhook KPI provides a mechanism for subsystems which * export helper hook points to clean up on vnet shutdown, so we don't need a * VNET_SYSUNINIT for Khelp. */ VNET_SYSINIT(khelp_vnet_init, SI_SUB_PROTO_END, SI_ORDER_FIRST, khelp_vnet_init, NULL);