net/9p/mod.c

   1 /*
   2  *  net/9p/9p.c
   3  *
   4  *  9P entry point
   5  *
   6  *  Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
   7  *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
   8  *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License version 2
  12  *  as published by the Free Software Foundation.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to:
  21  *  Free Software Foundation
  22  *  51 Franklin Street, Fifth Floor
  23  *  Boston, MA  02111-1301  USA
  24  *
  25  */
  26
  27 #include <linux/module.h>
  28 #include <linux/moduleparam.h>
  29 #include <net/9p/9p.h>
  30 #include <linux/fs.h>
  31 #include <linux/parser.h>
  32 #include <net/9p/client.h>
  33 #include <net/9p/transport.h>
  34 #include <linux/list.h>
  35 #include <linux/spinlock.h>
  36
  37 #ifdef CONFIG_NET_9P_DEBUG
  38 unsigned int p9_debug_level = 0;        /* feature-rific global debug level  */
  39 EXPORT_SYMBOL(p9_debug_level);
  40 module_param_named(debug, p9_debug_level, uint, 0);
  41 MODULE_PARM_DESC(debug, "9P debugging level");
  42 #endif
  43
  44 /*
  45  * Dynamic Transport Registration Routines
  46  *
  47  */
  48
  49 static DEFINE_SPINLOCK(v9fs_trans_lock);
  50 static LIST_HEAD(v9fs_trans_list);
  51
  52 /**
  53  * v9fs_register_trans - register a new transport with 9p
  54  * @m: structure describing the transport module and entry points
  55  *
  56  */
  57 void v9fs_register_trans(struct p9_trans_module *m)
  58 {
  59         spin_lock(&v9fs_trans_lock);
  60         list_add_tail(&m->list, &v9fs_trans_list);
  61         spin_unlock(&v9fs_trans_lock);
  62 }
  63 EXPORT_SYMBOL(v9fs_register_trans);
  64
  65 /**
  66  * v9fs_unregister_trans - unregister a 9p transport
  67  * @m: the transport to remove
  68  *
  69  */
  70 void v9fs_unregister_trans(struct p9_trans_module *m)
  71 {
  72         spin_lock(&v9fs_trans_lock);
  73         list_del_init(&m->list);
  74         spin_unlock(&v9fs_trans_lock);
  75 }
  76 EXPORT_SYMBOL(v9fs_unregister_trans);
  77
  78 /**
  79  * v9fs_get_trans_by_name - get transport with the matching name
  80  * @name: string identifying transport
  81  *
  82  */
  83 struct p9_trans_module *v9fs_get_trans_by_name(const substring_t *name)
  84 {
  85         struct p9_trans_module *t, *found = NULL;
  86
  87         spin_lock(&v9fs_trans_lock);
  88
  89         list_for_each_entry(t, &v9fs_trans_list, list)
  90                 if (strncmp(t->name, name->from, name->to-name->from) == 0 &&
  91                     try_module_get(t->owner)) {
  92                         found = t;
  93                         break;
  94                 }
  95
  96         spin_unlock(&v9fs_trans_lock);
  97         return found;
  98 }
  99 EXPORT_SYMBOL(v9fs_get_trans_by_name);
 100
 101 /**
 102  * v9fs_get_default_trans - get the default transport
 103  *
 104  */
 105
 106 struct p9_trans_module *v9fs_get_default_trans(void)
 107 {
 108         struct p9_trans_module *t, *found = NULL;
 109
 110         spin_lock(&v9fs_trans_lock);
 111
 112         list_for_each_entry(t, &v9fs_trans_list, list)
 113                 if (t->def && try_module_get(t->owner)) {
 114                         found = t;
 115                         break;
 116                 }
 117
 118         if (!found)
 119                 list_for_each_entry(t, &v9fs_trans_list, list)
 120                         if (try_module_get(t->owner)) {
 121                                 found = t;
 122                                 break;
 123                         }
 124
 125         spin_unlock(&v9fs_trans_lock);
 126         return found;
 127 }
 128 EXPORT_SYMBOL(v9fs_get_default_trans);
 129
 130 /**
 131  * v9fs_put_trans - put trans
 132  * @m: transport to put
 133  *
 134  */
 135 void v9fs_put_trans(struct p9_trans_module *m)
 136 {
 137         if (m)
 138                 module_put(m->owner);
 139 }
 140
 141 /**
 142  * v9fs_init - Initialize module
 143  *
 144  */
 145 static int __init init_p9(void)
 146 {
 147         int ret = 0;
 148
 149         p9_error_init();
 150         printk(KERN_INFO "Installing 9P2000 support\n");
 151         p9_trans_fd_init();
 152
 153         return ret;
 154 }
 155
 156 /**
 157  * v9fs_init - shutdown module
 158  *
 159  */
 160
 161 static void __exit exit_p9(void)
 162 {
 163         printk(KERN_INFO "Unloading 9P2000 support\n");
 164
 165         p9_trans_fd_exit();
 166 }
 167
 168 module_init(init_p9)
 169 module_exit(exit_p9)
 170
 171 MODULE_AUTHOR("Latchesar Ionkov <lucho@ionkov.net>");
 172 MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>");
 173 MODULE_AUTHOR("Ron Minnich <rminnich@lanl.gov>");
 174 MODULE_LICENSE("GPL");