net/9p/mod.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  net/9p/9p.c
   4  *
   5  *  9P entry point
   6  *
   7  *  Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
   8  *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
   9  *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
  10  */
  11
  12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  13
  14 #include <linux/module.h>
  15 #include <linux/errno.h>
  16 #include <linux/sched.h>
  17 #include <linux/moduleparam.h>
  18 #include <net/9p/9p.h>
  19 #include <linux/fs.h>
  20 #include <linux/parser.h>
  21 #include <net/9p/client.h>
  22 #include <net/9p/transport.h>
  23 #include <linux/list.h>
  24 #include <linux/spinlock.h>
  25
  26 #ifdef CONFIG_NET_9P_DEBUG
  27 unsigned int p9_debug_level;    /* feature-rific global debug level  */
  28 EXPORT_SYMBOL(p9_debug_level);
  29 module_param_named(debug, p9_debug_level, uint, 0);
  30 MODULE_PARM_DESC(debug, "9P debugging level");
  31
  32 void _p9_debug(enum p9_debug_flags level, const char *func,
  33                const char *fmt, ...)
  34 {
  35         struct va_format vaf;
  36         va_list args;
  37
  38         if ((p9_debug_level & level) != level)
  39                 return;
  40
  41         va_start(args, fmt);
  42
  43         vaf.fmt = fmt;
  44         vaf.va = &args;
  45
  46         if (level == P9_DEBUG_9P)
  47                 pr_notice("(%8.8d) %pV", task_pid_nr(current), &vaf);
  48         else
  49                 pr_notice("-- %s (%d): %pV", func, task_pid_nr(current), &vaf);
  50
  51         va_end(args);
  52 }
  53 EXPORT_SYMBOL(_p9_debug);
  54 #endif
  55
  56 /* Dynamic Transport Registration Routines */
  57
  58 static DEFINE_SPINLOCK(v9fs_trans_lock);
  59 static LIST_HEAD(v9fs_trans_list);
  60
  61 /**
  62  * v9fs_register_trans - register a new transport with 9p
  63  * @m: structure describing the transport module and entry points
  64  *
  65  */
  66 void v9fs_register_trans(struct p9_trans_module *m)
  67 {
  68         spin_lock(&v9fs_trans_lock);
  69         list_add_tail(&m->list, &v9fs_trans_list);
  70         spin_unlock(&v9fs_trans_lock);
  71 }
  72 EXPORT_SYMBOL(v9fs_register_trans);
  73
  74 /**
  75  * v9fs_unregister_trans - unregister a 9p transport
  76  * @m: the transport to remove
  77  *
  78  */
  79 void v9fs_unregister_trans(struct p9_trans_module *m)
  80 {
  81         spin_lock(&v9fs_trans_lock);
  82         list_del_init(&m->list);
  83         spin_unlock(&v9fs_trans_lock);
  84 }
  85 EXPORT_SYMBOL(v9fs_unregister_trans);
  86
  87 /**
  88  * v9fs_get_trans_by_name - get transport with the matching name
  89  * @s: string identifying transport
  90  *
  91  */
  92 struct p9_trans_module *v9fs_get_trans_by_name(char *s)
  93 {
  94         struct p9_trans_module *t, *found = NULL;
  95
  96         spin_lock(&v9fs_trans_lock);
  97
  98         list_for_each_entry(t, &v9fs_trans_list, list)
  99                 if (strcmp(t->name, s) == 0 &&
 100                     try_module_get(t->owner)) {
 101                         found = t;
 102                         break;
 103                 }
 104
 105         spin_unlock(&v9fs_trans_lock);
 106         return found;
 107 }
 108 EXPORT_SYMBOL(v9fs_get_trans_by_name);
 109
 110 /**
 111  * v9fs_get_default_trans - get the default transport
 112  *
 113  */
 114
 115 struct p9_trans_module *v9fs_get_default_trans(void)
 116 {
 117         struct p9_trans_module *t, *found = NULL;
 118
 119         spin_lock(&v9fs_trans_lock);
 120
 121         list_for_each_entry(t, &v9fs_trans_list, list)
 122                 if (t->def && try_module_get(t->owner)) {
 123                         found = t;
 124                         break;
 125                 }
 126
 127         if (!found)
 128                 list_for_each_entry(t, &v9fs_trans_list, list)
 129                         if (try_module_get(t->owner)) {
 130                                 found = t;
 131                                 break;
 132                         }
 133
 134         spin_unlock(&v9fs_trans_lock);
 135         return found;
 136 }
 137 EXPORT_SYMBOL(v9fs_get_default_trans);
 138
 139 /**
 140  * v9fs_put_trans - put trans
 141  * @m: transport to put
 142  *
 143  */
 144 void v9fs_put_trans(struct p9_trans_module *m)
 145 {
 146         if (m)
 147                 module_put(m->owner);
 148 }
 149
 150 /**
 151  * init_p9 - Initialize module
 152  *
 153  */
 154 static int __init init_p9(void)
 155 {
 156         int ret;
 157
 158         ret = p9_client_init();
 159         if (ret)
 160                 return ret;
 161
 162         p9_error_init();
 163         pr_info("Installing 9P2000 support\n");
 164         p9_trans_fd_init();
 165
 166         return ret;
 167 }
 168
 169 /**
 170  * exit_p9 - shutdown module
 171  *
 172  */
 173
 174 static void __exit exit_p9(void)
 175 {
 176         pr_info("Unloading 9P2000 support\n");
 177
 178         p9_trans_fd_exit();
 179         p9_client_exit();
 180 }
 181
 182 module_init(init_p9)
 183 module_exit(exit_p9)
 184
 185 MODULE_AUTHOR("Latchesar Ionkov <lucho@ionkov.net>");
 186 MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>");
 187 MODULE_AUTHOR("Ron Minnich <rminnich@lanl.gov>");
 188 MODULE_LICENSE("GPL");
 189 MODULE_DESCRIPTION("Plan 9 Resource Sharing Support (9P2000)");