fs/coda/inode.c

   1 /*
   2  * Super block/filesystem wide operations
   3  *
   4  * Copyright (C) 1996 Peter J. Braam <braam@maths.ox.ac.uk> and
   5  * Michael Callahan <callahan@maths.ox.ac.uk>
   6  *
   7  * Rewritten for Linux 2.1.  Peter Braam <braam@cs.cmu.edu>
   8  * Copyright (C) Carnegie Mellon University
   9  */
  10
  11 #define __NO_VERSION__
  12 #include <linux/module.h>
  13 #include <linux/kernel.h>
  14 #include <linux/mm.h>
  15 #include <linux/string.h>
  16 #include <linux/stat.h>
  17 #include <linux/errno.h>
  18 #include <linux/locks.h>
  19 #include <linux/unistd.h>
  20 #include <linux/smp_lock.h>
  21 #include <linux/file.h>
  22
  23 #include <asm/system.h>
  24 #include <asm/uaccess.h>
  25
  26 #include <linux/fs.h>
  27 #include <linux/vmalloc.h>
  28
  29 #include <linux/coda.h>
  30 #include <linux/coda_linux.h>
  31 #include <linux/coda_psdev.h>
  32 #include <linux/coda_fs_i.h>
  33 #include <linux/coda_cache.h>
  34
  35 /* VFS super_block ops */
  36 static struct super_block *coda_read_super(struct super_block *, void *, int);
  37 static void coda_read_inode(struct inode *);
  38 static void coda_clear_inode(struct inode *);
  39 static void coda_put_super(struct super_block *);
  40 static int coda_statfs(struct super_block *sb, struct statfs *buf);
  41
  42 /* exported operations */
  43 struct super_operations coda_super_operations =
  44 {
  45         read_inode:     coda_read_inode,
  46         clear_inode:    coda_clear_inode,
  47         put_super:      coda_put_super,
  48         statfs:         coda_statfs,
  49 };
  50
  51 static int get_device_index(struct coda_mount_data *data)
  52 {
  53         struct file *file;
  54         struct inode *inode;
  55         int idx;
  56
  57         if(data == NULL) {
  58                 printk("coda_read_super: Bad mount data\n");
  59                 return -1;
  60         }
  61
  62         if(data->version != CODA_MOUNT_VERSION) {
  63                 printk("coda_read_super: Bad mount version\n");
  64                 return -1;
  65         }
  66
  67         file = fget(data->fd);
  68         inode = NULL;
  69         if(file)
  70                 inode = file->f_dentry->d_inode;
  71
  72         if(!inode || !S_ISCHR(inode->i_mode) ||
  73            MAJOR(inode->i_rdev) != CODA_PSDEV_MAJOR) {
  74                 if(file)
  75                         fput(file);
  76
  77                 printk("coda_read_super: Bad file\n");
  78                 return -1;
  79         }
  80
  81         idx = MINOR(inode->i_rdev);
  82         fput(file);
  83
  84         if(idx < 0 || idx >= MAX_CODADEVS) {
  85                 printk("coda_read_super: Bad minor number\n");
  86                 return -1;
  87         }
  88
  89         return idx;
  90 }
  91
  92 static struct super_block * coda_read_super(struct super_block *sb,
  93                                             void *data, int silent)
  94 {
  95         struct inode *root = 0;
  96         struct coda_sb_info *sbi = NULL;
  97         struct venus_comm *vc = NULL;
  98         ViceFid fid;
  99         int error;
 100         int idx;
 101
 102         idx = get_device_index((struct coda_mount_data *) data);
 103
 104         /* Ignore errors in data, for backward compatibility */
 105         if(idx == -1)
 106                 idx = 0;
 107
 108         printk(KERN_INFO "coda_read_super: device index: %i\n", idx);
 109
 110         vc = &coda_comms[idx];
 111         if (!vc->vc_inuse) {
 112                 printk("coda_read_super: No pseudo device\n");
 113                 return NULL;
 114         }
 115
 116         if ( vc->vc_sb ) {
 117                 printk("coda_read_super: Device already mounted\n");
 118                 return NULL;
 119         }
 120
 121         sbi = kmalloc(sizeof(struct coda_sb_info), GFP_KERNEL);
 122         if(!sbi) {
 123                 return NULL;
 124         }
 125
 126         vc->vc_sb = sb;
 127
 128         sbi->sbi_sb = sb;
 129         sbi->sbi_vcomm = vc;
 130         INIT_LIST_HEAD(&sbi->sbi_cihead);
 131         init_MUTEX(&sbi->sbi_iget4_mutex);
 132
 133         sb->u.generic_sbp = sbi;
 134         sb->s_blocksize = 1024; /* XXXXX  what do we put here?? */
 135         sb->s_blocksize_bits = 10;
 136         sb->s_magic = CODA_SUPER_MAGIC;
 137         sb->s_op = &coda_super_operations;
 138
 139         /* get root fid from Venus: this needs the root inode */
 140         error = venus_rootfid(sb, &fid);
 141         if ( error ) {
 142                 printk("coda_read_super: coda_get_rootfid failed with %d\n",
 143                        error);
 144                 goto error;
 145         }
 146         printk("coda_read_super: rootfid is %s\n", coda_f2s(&fid));
 147
 148         /* make root inode */
 149         error = coda_cnode_make(&root, &fid, sb);
 150         if ( error || !root ) {
 151             printk("Failure of coda_cnode_make for root: error %d\n", error);
 152             goto error;
 153         }
 154
 155         printk("coda_read_super: rootinode is %ld dev %d\n",
 156                root->i_ino, root->i_dev);
 157         sb->s_root = d_alloc_root(root);
 158         return sb;
 159
 160  error:
 161         if (sbi) {
 162                 kfree(sbi);
 163                 if(vc)
 164                         vc->vc_sb = NULL;
 165         }
 166         if (root)
 167                 iput(root);
 168
 169         return NULL;
 170 }
 171
 172 static void coda_put_super(struct super_block *sb)
 173 {
 174         struct coda_sb_info *sbi;
 175
 176         sbi = coda_sbp(sb);
 177         sbi->sbi_vcomm->vc_sb = NULL;
 178         list_del_init(&sbi->sbi_cihead);
 179
 180         printk("Coda: Bye bye.\n");
 181         kfree(sbi);
 182 }
 183
 184 /* all filling in of inodes postponed until lookup */
 185 static void coda_read_inode(struct inode *inode)
 186 {
 187         struct coda_sb_info *sbi = coda_sbp(inode->i_sb);
 188         struct coda_inode_info *cii;
 189
 190         if (!sbi) BUG();
 191
 192         cii = ITOC(inode);
 193         if (!coda_isnullfid(&cii->c_fid)) {
 194             printk("coda_read_inode: initialized inode");
 195             return;
 196         }
 197
 198         cii->c_mapcount = 0;
 199         list_add(&cii->c_cilist, &sbi->sbi_cihead);
 200 }
 201
 202 static void coda_clear_inode(struct inode *inode)
 203 {
 204         struct coda_inode_info *cii = ITOC(inode);
 205
 206         CDEBUG(D_SUPER, " inode->ino: %ld, count: %d\n",
 207                inode->i_ino, atomic_read(&inode->i_count));
 208         CDEBUG(D_DOWNCALL, "clearing inode: %ld, %x\n", inode->i_ino, cii->c_flags);
 209
 210         list_del_init(&cii->c_cilist);
 211         coda_cache_clear_inode(inode);
 212 }
 213
 214 int coda_notify_change(struct dentry *de, struct iattr *iattr)
 215 {
 216         struct inode *inode = de->d_inode;
 217         struct coda_vattr vattr;
 218         int error;
 219
 220         memset(&vattr, 0, sizeof(vattr));
 221
 222         inode->i_ctime = CURRENT_TIME;
 223         coda_iattr_to_vattr(iattr, &vattr);
 224         vattr.va_type = C_VNON; /* cannot set type */
 225         CDEBUG(D_SUPER, "vattr.va_mode %o\n", vattr.va_mode);
 226
 227         /* Venus is responsible for truncating the container-file!!! */
 228         error = venus_setattr(inode->i_sb, coda_i2f(inode), &vattr);
 229
 230         if ( !error ) {
 231                 coda_vattr_to_iattr(inode, &vattr);
 232                 coda_cache_clear_inode(inode);
 233         }
 234         CDEBUG(D_SUPER, "inode.i_mode %o, error %d\n", inode->i_mode, error);
 235
 236         return error;
 237 }
 238
 239 struct inode_operations coda_file_inode_operations = {
 240         permission:     coda_permission,
 241         revalidate:     coda_revalidate_inode,
 242         setattr:        coda_notify_change,
 243 };
 244
 245 static int coda_statfs(struct super_block *sb, struct statfs *buf)
 246 {
 247         int error;
 248
 249         error = venus_statfs(sb, buf);
 250
 251         if (error) {
 252                 /* fake something like AFS does */
 253                 buf->f_blocks = 9000000;
 254                 buf->f_bfree  = 9000000;
 255                 buf->f_bavail = 9000000;
 256                 buf->f_files  = 9000000;
 257                 buf->f_ffree  = 9000000;
 258         }
 259
 260         /* and fill in the rest */
 261         buf->f_type = CODA_SUPER_MAGIC;
 262         buf->f_bsize = 1024;
 263         buf->f_namelen = CODA_MAXNAMLEN;
 264
 265         return 0;
 266 }
 267
 268 /* init_coda: used by filesystems.c to register coda */
 269
 270 DECLARE_FSTYPE( coda_fs_type, "coda", coda_read_super, 0);
 271