fs/coda/inode.c

   1 /*
   2  * Super block/filesystem wide operations
   3  *
   4  * Copryright (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
  21 #include <asm/system.h>
  22 #include <asm/uaccess.h>
  23
  24 #include <linux/fs.h>
  25 #include <linux/vmalloc.h>
  26 #include <asm/segment.h>
  27
  28 #include <linux/coda.h>
  29 #include <linux/coda_linux.h>
  30 #include <linux/coda_psdev.h>
  31 #include <linux/coda_fs_i.h>
  32 #include <linux/coda_cache.h>
  33
  34 /* VFS super_block ops */
  35 static struct super_block *coda_read_super(struct super_block *, void *, int);
  36 static void coda_read_inode(struct inode *);
  37 static void coda_put_inode(struct inode *);
  38 static void coda_delete_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         put_inode:      coda_put_inode,
  47         delete_inode:   coda_delete_inode,
  48         put_super:      coda_put_super,
  49         statfs:         coda_statfs,
  50 };
  51
  52 static struct super_block * coda_read_super(struct super_block *sb,
  53                                             void *data, int silent)
  54 {
  55         struct inode *psdev = 0, *root = 0;
  56         struct coda_sb_info *sbi = NULL;
  57         struct venus_comm *vc = NULL;
  58         ViceFid fid;
  59         kdev_t dev = sb->s_dev;
  60         int error;
  61
  62         ENTRY;
  63
  64         vc = &coda_upc_comm;
  65         sbi = &coda_super_info;
  66
  67         if ( sbi->sbi_sb ) {
  68                 printk("Already mounted\n");
  69                 EXIT;
  70                 return NULL;
  71         }
  72
  73         sbi->sbi_sb = sb;
  74         sbi->sbi_psdev = psdev;
  75         sbi->sbi_vcomm = vc;
  76         INIT_LIST_HEAD(&(sbi->sbi_cchead));
  77         INIT_LIST_HEAD(&(sbi->sbi_volroothead));
  78
  79         sb->u.generic_sbp = sbi;
  80         sb->s_blocksize = 1024; /* XXXXX  what do we put here?? */
  81         sb->s_blocksize_bits = 10;
  82         sb->s_magic = CODA_SUPER_MAGIC;
  83         sb->s_dev = dev;
  84         sb->s_op = &coda_super_operations;
  85
  86         /* get root fid from Venus: this needs the root inode */
  87         error = venus_rootfid(sb, &fid);
  88         if ( error ) {
  89                 printk("coda_read_super: coda_get_rootfid failed with %d\n",
  90                        error);
  91                 goto error;
  92         }
  93         printk("coda_read_super: rootfid is %s\n", coda_f2s(&fid));
  94
  95         /* make root inode */
  96         error = coda_cnode_make(&root, &fid, sb);
  97         if ( error || !root ) {
  98             printk("Failure of coda_cnode_make for root: error %d\n", error);
  99             goto error;
 100         }
 101
 102         printk("coda_read_super: rootinode is %ld dev %d\n",
 103                root->i_ino, root->i_dev);
 104         sbi->sbi_root = root;
 105         sb->s_root = d_alloc_root(root);
 106         EXIT;
 107         return sb;
 108
 109  error:
 110         EXIT;
 111         if (sbi) {
 112                 sbi->sbi_vcomm = NULL;
 113                 sbi->sbi_root = NULL;
 114                 sbi->sbi_sb = NULL;
 115         }
 116         if (root) {
 117                 iput(root);
 118         }
 119         return NULL;
 120 }
 121
 122 static void coda_put_super(struct super_block *sb)
 123 {
 124         struct coda_sb_info *sb_info;
 125
 126         ENTRY;
 127
 128         coda_cache_clear_all(sb);
 129         sb_info = coda_sbp(sb);
 130         coda_super_info.sbi_sb = NULL;
 131         printk("Coda: Bye bye.\n");
 132         memset(sb_info, 0, sizeof(* sb_info));
 133
 134         EXIT;
 135 }
 136
 137 /* all filling in of inodes postponed until lookup */
 138 static void coda_read_inode(struct inode *inode)
 139 {
 140         struct coda_inode_info *cii;
 141         ENTRY;
 142         cii = ITOC(inode);
 143         cii->c_magic = 0;
 144         return;
 145 }
 146
 147 static void coda_put_inode(struct inode *inode)
 148 {
 149         ENTRY;
 150
 151         CDEBUG(D_INODE,"ino: %ld, count %d\n", inode->i_ino, atomic_read(&inode->i_count));
 152
 153         if ( atomic_read(&inode->i_count) == 1 ) {
 154                 write_inode_now(inode);
 155                 inode->i_nlink = 0;
 156         }
 157 }
 158
 159 static void coda_delete_inode(struct inode *inode)
 160 {
 161         struct coda_inode_info *cii;
 162         struct inode *open_inode;
 163
 164         ENTRY;
 165         CDEBUG(D_SUPER, " inode->ino: %ld, count: %d\n",
 166                inode->i_ino, atomic_read(&inode->i_count));
 167
 168         cii = ITOC(inode);
 169         if ( inode->i_ino == CTL_INO || cii->c_magic != CODA_CNODE_MAGIC ) {
 170                 clear_inode(inode);
 171                 return;
 172         }
 173
 174         if ( ! list_empty(&cii->c_volrootlist) ) {
 175                 list_del(&cii->c_volrootlist);
 176                 INIT_LIST_HEAD(&cii->c_volrootlist);
 177         }
 178
 179         open_inode = cii->c_ovp;
 180         if ( open_inode ) {
 181                 CDEBUG(D_SUPER, "DELINO cached file: ino %ld count %d.\n",
 182                        open_inode->i_ino,  atomic_read(&open_inode->i_count));
 183                 cii->c_ovp = NULL;
 184                 inode->i_mapping = &inode->i_data;
 185                 iput(open_inode);
 186         }
 187
 188         coda_cache_clear_inode(inode);
 189         CDEBUG(D_DOWNCALL, "clearing inode: %ld, %x\n", inode->i_ino, cii->c_flags);
 190         inode->u.coda_i.c_magic = 0;
 191         clear_inode(inode);
 192         EXIT;
 193 }
 194
 195 int coda_notify_change(struct dentry *de, struct iattr *iattr)
 196 {
 197         struct inode *inode = de->d_inode;
 198         struct coda_inode_info *cii;
 199         struct coda_vattr vattr;
 200         int error;
 201
 202         ENTRY;
 203         memset(&vattr, 0, sizeof(vattr));
 204         cii = ITOC(inode);
 205         CHECK_CNODE(cii);
 206
 207         coda_iattr_to_vattr(iattr, &vattr);
 208         vattr.va_type = C_VNON; /* cannot set type */
 209         CDEBUG(D_SUPER, "vattr.va_mode %o\n", vattr.va_mode);
 210
 211         error = venus_setattr(inode->i_sb, &cii->c_fid, &vattr);
 212
 213         if ( !error ) {
 214                 coda_vattr_to_iattr(inode, &vattr);
 215                 coda_cache_clear_inode(inode);
 216         }
 217         CDEBUG(D_SUPER, "inode.i_mode %o, error %d\n",
 218                inode->i_mode, error);
 219
 220         EXIT;
 221         return error;
 222 }
 223
 224 static int coda_statfs(struct super_block *sb, struct statfs *buf)
 225 {
 226         int error;
 227
 228         error = venus_statfs(sb, buf);
 229
 230         if (error) {
 231                 /* fake something like AFS does */
 232                 buf->f_blocks = 9000000;
 233                 buf->f_bfree  = 9000000;
 234                 buf->f_bavail = 9000000;
 235                 buf->f_files  = 9000000;
 236                 buf->f_ffree  = 9000000;
 237         }
 238
 239         /* and fill in the rest */
 240         buf->f_type = CODA_SUPER_MAGIC;
 241         buf->f_bsize = 1024;
 242         buf->f_namelen = CODA_MAXNAMLEN;
 243
 244         return 0;
 245 }
 246
 247
 248 /* init_coda: used by filesystems.c to register coda */
 249
 250 DECLARE_FSTYPE( coda_fs_type, "coda", coda_read_super, 0);
 251
 252 int init_coda_fs(void)
 253 {
 254         return register_filesystem(&coda_fs_type);
 255 }
 256
 257
 258