2 * Super block/filesystem wide operations
4 * Copyright (C) 1996 Peter J. Braam <braam@maths.ox.ac.uk> and
5 * Michael Callahan <callahan@maths.ox.ac.uk>
7 * Rewritten for Linux 2.1. Peter Braam <braam@cs.cmu.edu>
8 * Copyright (C) Carnegie Mellon University
11 #include <linux/module.h>
12 #include <linux/kernel.h>
14 #include <linux/string.h>
15 #include <linux/stat.h>
16 #include <linux/errno.h>
17 #include <linux/unistd.h>
18 #include <linux/mutex.h>
19 #include <linux/spinlock.h>
20 #include <linux/file.h>
21 #include <linux/vfs.h>
22 #include <linux/slab.h>
23 #include <linux/pid_namespace.h>
25 #include <asm/uaccess.h>
28 #include <linux/vmalloc.h>
30 #include <linux/coda.h>
31 #include <linux/coda_psdev.h>
32 #include "coda_linux.h"
33 #include "coda_cache.h"
37 /* VFS super_block ops */
38 static void coda_evict_inode(struct inode
*);
39 static void coda_put_super(struct super_block
*);
40 static int coda_statfs(struct dentry
*dentry
, struct kstatfs
*buf
);
42 static struct kmem_cache
* coda_inode_cachep
;
44 static struct inode
*coda_alloc_inode(struct super_block
*sb
)
46 struct coda_inode_info
*ei
;
47 ei
= kmem_cache_alloc(coda_inode_cachep
, GFP_KERNEL
);
50 memset(&ei
->c_fid
, 0, sizeof(struct CodaFid
));
52 ei
->c_uid
= GLOBAL_ROOT_UID
;
53 ei
->c_cached_perm
= 0;
54 spin_lock_init(&ei
->c_lock
);
55 return &ei
->vfs_inode
;
58 static void coda_i_callback(struct rcu_head
*head
)
60 struct inode
*inode
= container_of(head
, struct inode
, i_rcu
);
61 kmem_cache_free(coda_inode_cachep
, ITOC(inode
));
64 static void coda_destroy_inode(struct inode
*inode
)
66 call_rcu(&inode
->i_rcu
, coda_i_callback
);
69 static void init_once(void *foo
)
71 struct coda_inode_info
*ei
= (struct coda_inode_info
*) foo
;
73 inode_init_once(&ei
->vfs_inode
);
76 int __init
coda_init_inodecache(void)
78 coda_inode_cachep
= kmem_cache_create("coda_inode_cache",
79 sizeof(struct coda_inode_info
),
80 0, SLAB_RECLAIM_ACCOUNT
|SLAB_MEM_SPREAD
,
82 if (coda_inode_cachep
== NULL
)
87 void coda_destroy_inodecache(void)
90 * Make sure all delayed rcu free inodes are flushed before we
94 kmem_cache_destroy(coda_inode_cachep
);
97 static int coda_remount(struct super_block
*sb
, int *flags
, char *data
)
100 *flags
|= MS_NOATIME
;
104 /* exported operations */
105 static const struct super_operations coda_super_operations
=
107 .alloc_inode
= coda_alloc_inode
,
108 .destroy_inode
= coda_destroy_inode
,
109 .evict_inode
= coda_evict_inode
,
110 .put_super
= coda_put_super
,
111 .statfs
= coda_statfs
,
112 .remount_fs
= coda_remount
,
115 static int get_device_index(struct coda_mount_data
*data
)
122 printk("coda_read_super: Bad mount data\n");
126 if (data
->version
!= CODA_MOUNT_VERSION
) {
127 printk("coda_read_super: Bad mount version\n");
134 inode
= file_inode(f
.file
);
135 if (!S_ISCHR(inode
->i_mode
) || imajor(inode
) != CODA_PSDEV_MAJOR
) {
143 if (idx
< 0 || idx
>= MAX_CODADEVS
) {
144 printk("coda_read_super: Bad minor number\n");
150 printk("coda_read_super: Bad file\n");
154 static int coda_fill_super(struct super_block
*sb
, void *data
, int silent
)
156 struct inode
*root
= NULL
;
157 struct venus_comm
*vc
;
162 if (task_active_pid_ns(current
) != &init_pid_ns
)
165 idx
= get_device_index((struct coda_mount_data
*) data
);
167 /* Ignore errors in data, for backward compatibility */
171 printk(KERN_INFO
"coda_read_super: device index: %i\n", idx
);
173 vc
= &coda_comms
[idx
];
174 mutex_lock(&vc
->vc_mutex
);
177 printk("coda_read_super: No pseudo device\n");
183 printk("coda_read_super: Device already mounted\n");
188 error
= bdi_setup_and_register(&vc
->bdi
, "coda", BDI_CAP_MAP_COPY
);
193 mutex_unlock(&vc
->vc_mutex
);
196 sb
->s_flags
|= MS_NOATIME
;
197 sb
->s_blocksize
= 4096; /* XXXXX what do we put here?? */
198 sb
->s_blocksize_bits
= 12;
199 sb
->s_magic
= CODA_SUPER_MAGIC
;
200 sb
->s_op
= &coda_super_operations
;
201 sb
->s_d_op
= &coda_dentry_operations
;
202 sb
->s_bdi
= &vc
->bdi
;
204 /* get root fid from Venus: this needs the root inode */
205 error
= venus_rootfid(sb
, &fid
);
207 printk("coda_read_super: coda_get_rootfid failed with %d\n",
211 printk("coda_read_super: rootfid is %s\n", coda_f2s(&fid
));
213 /* make root inode */
214 root
= coda_cnode_make(&fid
, sb
);
216 error
= PTR_ERR(root
);
217 printk("Failure of coda_cnode_make for root: error %d\n", error
);
221 printk("coda_read_super: rootinode is %ld dev %s\n",
222 root
->i_ino
, root
->i_sb
->s_id
);
223 sb
->s_root
= d_make_root(root
);
231 mutex_lock(&vc
->vc_mutex
);
232 bdi_destroy(&vc
->bdi
);
234 sb
->s_fs_info
= NULL
;
236 mutex_unlock(&vc
->vc_mutex
);
240 static void coda_put_super(struct super_block
*sb
)
242 struct venus_comm
*vcp
= coda_vcp(sb
);
243 mutex_lock(&vcp
->vc_mutex
);
244 bdi_destroy(&vcp
->bdi
);
246 sb
->s_fs_info
= NULL
;
247 mutex_unlock(&vcp
->vc_mutex
);
249 printk("Coda: Bye bye.\n");
252 static void coda_evict_inode(struct inode
*inode
)
254 truncate_inode_pages_final(&inode
->i_data
);
256 coda_cache_clear_inode(inode
);
259 int coda_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
, struct kstat
*stat
)
261 int err
= coda_revalidate_inode(dentry
->d_inode
);
263 generic_fillattr(dentry
->d_inode
, stat
);
267 int coda_setattr(struct dentry
*de
, struct iattr
*iattr
)
269 struct inode
*inode
= de
->d_inode
;
270 struct coda_vattr vattr
;
273 memset(&vattr
, 0, sizeof(vattr
));
275 inode
->i_ctime
= CURRENT_TIME_SEC
;
276 coda_iattr_to_vattr(iattr
, &vattr
);
277 vattr
.va_type
= C_VNON
; /* cannot set type */
279 /* Venus is responsible for truncating the container-file!!! */
280 error
= venus_setattr(inode
->i_sb
, coda_i2f(inode
), &vattr
);
283 coda_vattr_to_iattr(inode
, &vattr
);
284 coda_cache_clear_inode(inode
);
289 const struct inode_operations coda_file_inode_operations
= {
290 .permission
= coda_permission
,
291 .getattr
= coda_getattr
,
292 .setattr
= coda_setattr
,
295 static int coda_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
299 error
= venus_statfs(dentry
, buf
);
302 /* fake something like AFS does */
303 buf
->f_blocks
= 9000000;
304 buf
->f_bfree
= 9000000;
305 buf
->f_bavail
= 9000000;
306 buf
->f_files
= 9000000;
307 buf
->f_ffree
= 9000000;
310 /* and fill in the rest */
311 buf
->f_type
= CODA_SUPER_MAGIC
;
313 buf
->f_namelen
= CODA_MAXNAMLEN
;
318 /* init_coda: used by filesystems.c to register coda */
320 static struct dentry
*coda_mount(struct file_system_type
*fs_type
,
321 int flags
, const char *dev_name
, void *data
)
323 return mount_nodev(fs_type
, flags
, data
, coda_fill_super
);
326 struct file_system_type coda_fs_type
= {
327 .owner
= THIS_MODULE
,
330 .kill_sb
= kill_anon_super
,
331 .fs_flags
= FS_BINARY_MOUNTDATA
,
333 MODULE_ALIAS_FS("coda");