drivers/isdn/capi/capifs.c

   1 /* $Id: capifs.c,v 1.1.2.3 2004/01/16 21:09:26 keil Exp $
   2  *
   3  * Copyright 2000 by Carsten Paeth <calle@calle.de>
   4  *
   5  * Heavily based on devpts filesystem from H. Peter Anvin
   6  *
   7  * This software may be used and distributed according to the terms
   8  * of the GNU General Public License, incorporated herein by reference.
   9  *
  10  */
  11
  12 #include <linux/fs.h>
  13 #include <linux/mount.h>
  14 #include <linux/namei.h>
  15 #include <linux/module.h>
  16 #include <linux/init.h>
  17 #include <linux/ctype.h>
  18 #include <linux/sched.h>        /* current */
  19
  20 #include "capifs.h"
  21
  22 MODULE_DESCRIPTION("CAPI4Linux: /dev/capi/ filesystem");
  23 MODULE_AUTHOR("Carsten Paeth");
  24 MODULE_LICENSE("GPL");
  25
  26 /* ------------------------------------------------------------------ */
  27
  28 #define CAPIFS_SUPER_MAGIC (('C'<<8)|'N')
  29
  30 static struct vfsmount *capifs_mnt;
  31 static int capifs_mnt_count;
  32
  33 static struct {
  34         int setuid;
  35         int setgid;
  36         uid_t   uid;
  37         gid_t   gid;
  38         umode_t mode;
  39 } config = {.mode = 0600};
  40
  41 /* ------------------------------------------------------------------ */
  42
  43 static int capifs_remount(struct super_block *s, int *flags, char *data)
  44 {
  45         int setuid = 0;
  46         int setgid = 0;
  47         uid_t uid = 0;
  48         gid_t gid = 0;
  49         umode_t mode = 0600;
  50         char *this_char;
  51         char *new_opt = kstrdup(data, GFP_KERNEL);
  52
  53         this_char = NULL;
  54         while ((this_char = strsep(&data, ",")) != NULL) {
  55                 int n;
  56                 char dummy;
  57                 if (!*this_char)
  58                         continue;
  59                 if (sscanf(this_char, "uid=%i%c", &n, &dummy) == 1) {
  60                         setuid = 1;
  61                         uid = n;
  62                 } else if (sscanf(this_char, "gid=%i%c", &n, &dummy) == 1) {
  63                         setgid = 1;
  64                         gid = n;
  65                 } else if (sscanf(this_char, "mode=%o%c", &n, &dummy) == 1)
  66                         mode = n & ~S_IFMT;
  67                 else {
  68                         kfree(new_opt);
  69                         printk("capifs: called with bogus options\n");
  70                         return -EINVAL;
  71                 }
  72         }
  73
  74         mutex_lock(&s->s_root->d_inode->i_mutex);
  75
  76         replace_mount_options(s, new_opt);
  77         config.setuid  = setuid;
  78         config.setgid  = setgid;
  79         config.uid     = uid;
  80         config.gid     = gid;
  81         config.mode    = mode;
  82
  83         mutex_unlock(&s->s_root->d_inode->i_mutex);
  84
  85         return 0;
  86 }
  87
  88 static const struct super_operations capifs_sops =
  89 {
  90         .statfs         = simple_statfs,
  91         .remount_fs     = capifs_remount,
  92         .show_options   = generic_show_options,
  93 };
  94
  95
  96 static int
  97 capifs_fill_super(struct super_block *s, void *data, int silent)
  98 {
  99         struct inode * inode;
 100
 101         s->s_blocksize = 1024;
 102         s->s_blocksize_bits = 10;
 103         s->s_magic = CAPIFS_SUPER_MAGIC;
 104         s->s_op = &capifs_sops;
 105         s->s_time_gran = 1;
 106
 107         inode = new_inode(s);
 108         if (!inode)
 109                 goto fail;
 110         inode->i_ino = 1;
 111         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
 112         inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO | S_IWUSR;
 113         inode->i_op = &simple_dir_inode_operations;
 114         inode->i_fop = &simple_dir_operations;
 115         inode->i_nlink = 2;
 116
 117         s->s_root = d_alloc_root(inode);
 118         if (s->s_root)
 119                 return 0;
 120
 121         printk("capifs: get root dentry failed\n");
 122         iput(inode);
 123 fail:
 124         return -ENOMEM;
 125 }
 126
 127 static int capifs_get_sb(struct file_system_type *fs_type,
 128         int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 129 {
 130         return get_sb_single(fs_type, flags, data, capifs_fill_super, mnt);
 131 }
 132
 133 static struct file_system_type capifs_fs_type = {
 134         .owner          = THIS_MODULE,
 135         .name           = "capifs",
 136         .get_sb         = capifs_get_sb,
 137         .kill_sb        = kill_anon_super,
 138 };
 139
 140 static struct dentry *new_ncci(unsigned int number, dev_t device)
 141 {
 142         struct super_block *s = capifs_mnt->mnt_sb;
 143         struct dentry *root = s->s_root;
 144         struct dentry *dentry;
 145         struct inode *inode;
 146         char name[10];
 147         int namelen;
 148
 149         mutex_lock(&root->d_inode->i_mutex);
 150
 151         namelen = sprintf(name, "%d", number);
 152         dentry = lookup_one_len(name, root, namelen);
 153         if (IS_ERR(dentry)) {
 154                 dentry = NULL;
 155                 goto unlock_out;
 156         }
 157
 158         if (dentry->d_inode) {
 159                 dput(dentry);
 160                 dentry = NULL;
 161                 goto unlock_out;
 162         }
 163
 164         inode = new_inode(s);
 165         if (!inode) {
 166                 dput(dentry);
 167                 dentry = NULL;
 168                 goto unlock_out;
 169         }
 170
 171         /* config contents is protected by root's i_mutex */
 172         inode->i_uid = config.setuid ? config.uid : current_fsuid();
 173         inode->i_gid = config.setgid ? config.gid : current_fsgid();
 174         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
 175         inode->i_ino = number + 2;
 176         init_special_inode(inode, S_IFCHR|config.mode, device);
 177
 178         d_instantiate(dentry, inode);
 179         dget(dentry);
 180
 181 unlock_out:
 182         mutex_unlock(&root->d_inode->i_mutex);
 183
 184         return dentry;
 185 }
 186
 187 struct dentry *capifs_new_ncci(unsigned int number, dev_t device)
 188 {
 189         struct dentry *dentry;
 190
 191         if (simple_pin_fs(&capifs_fs_type, &capifs_mnt, &capifs_mnt_count) < 0)
 192                 return NULL;
 193
 194         dentry = new_ncci(number, device);
 195         if (!dentry)
 196                 simple_release_fs(&capifs_mnt, &capifs_mnt_count);
 197
 198         return dentry;
 199 }
 200
 201 void capifs_free_ncci(struct dentry *dentry)
 202 {
 203         struct dentry *root = capifs_mnt->mnt_sb->s_root;
 204         struct inode *inode;
 205
 206         if (!dentry)
 207                 return;
 208
 209         mutex_lock(&root->d_inode->i_mutex);
 210
 211         inode = dentry->d_inode;
 212         if (inode) {
 213                 drop_nlink(inode);
 214                 d_delete(dentry);
 215                 dput(dentry);
 216         }
 217         dput(dentry);
 218
 219         mutex_unlock(&root->d_inode->i_mutex);
 220
 221         simple_release_fs(&capifs_mnt, &capifs_mnt_count);
 222 }
 223
 224 static int __init capifs_init(void)
 225 {
 226         return register_filesystem(&capifs_fs_type);
 227 }
 228
 229 static void __exit capifs_exit(void)
 230 {
 231         unregister_filesystem(&capifs_fs_type);
 232 }
 233
 234 EXPORT_SYMBOL(capifs_new_ncci);
 235 EXPORT_SYMBOL(capifs_free_ncci);
 236
 237 module_init(capifs_init);
 238 module_exit(capifs_exit);