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 pr_warn("%s: Bad mount data\n", __func__
);
126 if (data
->version
!= CODA_MOUNT_VERSION
) {
127 pr_warn("%s: Bad mount version\n", __func__
);
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 pr_warn("%s: Bad minor number\n", __func__
);
150 pr_warn("%s: Bad file\n", __func__
);
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 pr_info("%s: device index: %i\n", __func__
, idx
);
173 vc
= &coda_comms
[idx
];
174 mutex_lock(&vc
->vc_mutex
);
177 pr_warn("%s: No pseudo device\n", __func__
);
183 pr_warn("%s: Device already mounted\n", __func__
);
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 pr_warn("%s: coda_get_rootfid failed with %d\n",
211 pr_info("%s: rootfid is %s\n", __func__
, coda_f2s(&fid
));
213 /* make root inode */
214 root
= coda_cnode_make(&fid
, sb
);
216 error
= PTR_ERR(root
);
217 pr_warn("Failure of coda_cnode_make for root: error %d\n",
222 pr_info("%s: rootinode is %ld dev %s\n",
223 __func__
, root
->i_ino
, root
->i_sb
->s_id
);
224 sb
->s_root
= d_make_root(root
);
232 mutex_lock(&vc
->vc_mutex
);
233 bdi_destroy(&vc
->bdi
);
235 sb
->s_fs_info
= NULL
;
237 mutex_unlock(&vc
->vc_mutex
);
241 static void coda_put_super(struct super_block
*sb
)
243 struct venus_comm
*vcp
= coda_vcp(sb
);
244 mutex_lock(&vcp
->vc_mutex
);
245 bdi_destroy(&vcp
->bdi
);
247 sb
->s_fs_info
= NULL
;
248 mutex_unlock(&vcp
->vc_mutex
);
250 pr_info("Bye bye.\n");
253 static void coda_evict_inode(struct inode
*inode
)
255 truncate_inode_pages_final(&inode
->i_data
);
257 coda_cache_clear_inode(inode
);
260 int coda_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
, struct kstat
*stat
)
262 int err
= coda_revalidate_inode(dentry
->d_inode
);
264 generic_fillattr(dentry
->d_inode
, stat
);
268 int coda_setattr(struct dentry
*de
, struct iattr
*iattr
)
270 struct inode
*inode
= de
->d_inode
;
271 struct coda_vattr vattr
;
274 memset(&vattr
, 0, sizeof(vattr
));
276 inode
->i_ctime
= CURRENT_TIME_SEC
;
277 coda_iattr_to_vattr(iattr
, &vattr
);
278 vattr
.va_type
= C_VNON
; /* cannot set type */
280 /* Venus is responsible for truncating the container-file!!! */
281 error
= venus_setattr(inode
->i_sb
, coda_i2f(inode
), &vattr
);
284 coda_vattr_to_iattr(inode
, &vattr
);
285 coda_cache_clear_inode(inode
);
290 const struct inode_operations coda_file_inode_operations
= {
291 .permission
= coda_permission
,
292 .getattr
= coda_getattr
,
293 .setattr
= coda_setattr
,
296 static int coda_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
300 error
= venus_statfs(dentry
, buf
);
303 /* fake something like AFS does */
304 buf
->f_blocks
= 9000000;
305 buf
->f_bfree
= 9000000;
306 buf
->f_bavail
= 9000000;
307 buf
->f_files
= 9000000;
308 buf
->f_ffree
= 9000000;
311 /* and fill in the rest */
312 buf
->f_type
= CODA_SUPER_MAGIC
;
314 buf
->f_namelen
= CODA_MAXNAMLEN
;
319 /* init_coda: used by filesystems.c to register coda */
321 static struct dentry
*coda_mount(struct file_system_type
*fs_type
,
322 int flags
, const char *dev_name
, void *data
)
324 return mount_nodev(fs_type
, flags
, data
, coda_fill_super
);
327 struct file_system_type coda_fs_type
= {
328 .owner
= THIS_MODULE
,
331 .kill_sb
= kill_anon_super
,
332 .fs_flags
= FS_BINARY_MOUNTDATA
,
334 MODULE_ALIAS_FS("coda");