LXR linux/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
  38unsigned int p9_debug_level = 0;        /* feature-rific global debug level  */
  39EXPORT_SYMBOL(p9_debug_level);
  40module_param_named(debug, p9_debug_level, uint, 0);
  41MODULE_PARM_DESC(debug, "9P debugging level");
  42#endif
  43
  44/*
  45 * Dynamic Transport Registration Routines
  46 *
  47 */
  48
  49static DEFINE_SPINLOCK(v9fs_trans_lock);
  50static 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 */
  57void 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}
  63EXPORT_SYMBOL(v9fs_register_trans);
  64
  65/**
  66 * v9fs_unregister_trans - unregister a 9p transport
  67 * @m: the transport to remove
  68 *
  69 */
  70void 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}
  76EXPORT_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 */
  83struct 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}
  99EXPORT_SYMBOL(v9fs_get_trans_by_name);
 100
 101/**
 102 * v9fs_get_default_trans - get the default transport
 103 *
 104 */
 105
 106struct 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}
 128EXPORT_SYMBOL(v9fs_get_default_trans);
 129
 130/**
 131 * v9fs_put_trans - put trans
 132 * @m: transport to put
 133 *
 134 */
 135void 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 */
 145static 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
 161static void __exit exit_p9(void)
 162{
 163        printk(KERN_INFO "Unloading 9P2000 support\n");
 164
 165        p9_trans_fd_exit();
 166}
 167
 168module_init(init_p9)
 169module_exit(exit_p9)
 170
 171MODULE_AUTHOR("Latchesar Ionkov <lucho@ionkov.net>");
 172MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>");
 173MODULE_AUTHOR("Ron Minnich <rminnich@lanl.gov>");
 174MODULE_LICENSE("GPL");
 175