root/net/9p/mod.c

DEFINITIONS

1. _p9_debug
2. v9fs_register_trans
3. v9fs_unregister_trans
4. v9fs_get_trans_by_name
5. v9fs_get_default_trans
6. v9fs_put_trans
7. init_p9
8. exit_p9

   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 = 0;        /* 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 /*
  57  * Dynamic Transport Registration Routines
  58  *
  59  */
  60 
  61 static DEFINE_SPINLOCK(v9fs_trans_lock);
  62 static LIST_HEAD(v9fs_trans_list);
  63 
  64 /**
  65  * v9fs_register_trans - register a new transport with 9p
  66  * @m: structure describing the transport module and entry points
  67  *
  68  */
  69 void v9fs_register_trans(struct p9_trans_module *m)
  70 {
  71         spin_lock(&v9fs_trans_lock);
  72         list_add_tail(&m->list, &v9fs_trans_list);
  73         spin_unlock(&v9fs_trans_lock);
  74 }
  75 EXPORT_SYMBOL(v9fs_register_trans);
  76 
  77 /**
  78  * v9fs_unregister_trans - unregister a 9p transport
  79  * @m: the transport to remove
  80  *
  81  */
  82 void v9fs_unregister_trans(struct p9_trans_module *m)
  83 {
  84         spin_lock(&v9fs_trans_lock);
  85         list_del_init(&m->list);
  86         spin_unlock(&v9fs_trans_lock);
  87 }
  88 EXPORT_SYMBOL(v9fs_unregister_trans);
  89 
  90 /**
  91  * v9fs_get_trans_by_name - get transport with the matching name
  92  * @s: string identifying transport
  93  *
  94  */
  95 struct p9_trans_module *v9fs_get_trans_by_name(char *s)
  96 {
  97         struct p9_trans_module *t, *found = NULL;
  98 
  99         spin_lock(&v9fs_trans_lock);
 100 
 101         list_for_each_entry(t, &v9fs_trans_list, list)
 102                 if (strcmp(t->name, s) == 0 &&
 103                     try_module_get(t->owner)) {
 104                         found = t;
 105                         break;
 106                 }
 107 
 108         spin_unlock(&v9fs_trans_lock);
 109         return found;
 110 }
 111 EXPORT_SYMBOL(v9fs_get_trans_by_name);
 112 
 113 /**
 114  * v9fs_get_default_trans - get the default transport
 115  *
 116  */
 117 
 118 struct p9_trans_module *v9fs_get_default_trans(void)
 119 {
 120         struct p9_trans_module *t, *found = NULL;
 121 
 122         spin_lock(&v9fs_trans_lock);
 123 
 124         list_for_each_entry(t, &v9fs_trans_list, list)
 125                 if (t->def && try_module_get(t->owner)) {
 126                         found = t;
 127                         break;
 128                 }
 129 
 130         if (!found)
 131                 list_for_each_entry(t, &v9fs_trans_list, list)
 132                         if (try_module_get(t->owner)) {
 133                                 found = t;
 134                                 break;
 135                         }
 136 
 137         spin_unlock(&v9fs_trans_lock);
 138         return found;
 139 }
 140 EXPORT_SYMBOL(v9fs_get_default_trans);
 141 
 142 /**
 143  * v9fs_put_trans - put trans
 144  * @m: transport to put
 145  *
 146  */
 147 void v9fs_put_trans(struct p9_trans_module *m)
 148 {
 149         if (m)
 150                 module_put(m->owner);
 151 }
 152 
 153 /**
 154  * init_p9 - Initialize module
 155  *
 156  */
 157 static int __init init_p9(void)
 158 {
 159         int ret;
 160 
 161         ret = p9_client_init();
 162         if (ret)
 163                 return ret;
 164 
 165         p9_error_init();
 166         pr_info("Installing 9P2000 support\n");
 167         p9_trans_fd_init();
 168 
 169         return ret;
 170 }
 171 
 172 /**
 173  * exit_p9 - shutdown module
 174  *
 175  */
 176 
 177 static void __exit exit_p9(void)
 178 {
 179         pr_info("Unloading 9P2000 support\n");
 180 
 181         p9_trans_fd_exit();
 182         p9_client_exit();
 183 }
 184 
 185 module_init(init_p9)
 186 module_exit(exit_p9)
 187 
 188 MODULE_AUTHOR("Latchesar Ionkov <lucho@ionkov.net>");
 189 MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>");
 190 MODULE_AUTHOR("Ron Minnich <rminnich@lanl.gov>");
 191 MODULE_LICENSE("GPL");