Root/
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 | #include <linux/module.h> |
12 | #include <linux/kernel.h> |
13 | #include <linux/mm.h> |
14 | #include <linux/string.h> |
15 | #include <linux/stat.h> |
16 | #include <linux/errno.h> |
17 | #include <linux/unistd.h> |
18 | #include <linux/smp_lock.h> |
19 | #include <linux/file.h> |
20 | #include <linux/vfs.h> |
21 | #include <linux/slab.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 | #include "coda_int.h" |
36 | |
37 | /* VFS super_block ops */ |
38 | static void coda_clear_inode(struct inode *); |
39 | static void coda_put_super(struct super_block *); |
40 | static int coda_statfs(struct dentry *dentry, struct kstatfs *buf); |
41 | |
42 | static struct kmem_cache * coda_inode_cachep; |
43 | |
44 | static struct inode *coda_alloc_inode(struct super_block *sb) |
45 | { |
46 | struct coda_inode_info *ei; |
47 | ei = (struct coda_inode_info *)kmem_cache_alloc(coda_inode_cachep, GFP_KERNEL); |
48 | if (!ei) |
49 | return NULL; |
50 | memset(&ei->c_fid, 0, sizeof(struct CodaFid)); |
51 | ei->c_flags = 0; |
52 | ei->c_uid = 0; |
53 | ei->c_cached_perm = 0; |
54 | return &ei->vfs_inode; |
55 | } |
56 | |
57 | static void coda_destroy_inode(struct inode *inode) |
58 | { |
59 | kmem_cache_free(coda_inode_cachep, ITOC(inode)); |
60 | } |
61 | |
62 | static void init_once(void *foo) |
63 | { |
64 | struct coda_inode_info *ei = (struct coda_inode_info *) foo; |
65 | |
66 | inode_init_once(&ei->vfs_inode); |
67 | } |
68 | |
69 | int coda_init_inodecache(void) |
70 | { |
71 | coda_inode_cachep = kmem_cache_create("coda_inode_cache", |
72 | sizeof(struct coda_inode_info), |
73 | 0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, |
74 | init_once); |
75 | if (coda_inode_cachep == NULL) |
76 | return -ENOMEM; |
77 | return 0; |
78 | } |
79 | |
80 | void coda_destroy_inodecache(void) |
81 | { |
82 | kmem_cache_destroy(coda_inode_cachep); |
83 | } |
84 | |
85 | static int coda_remount(struct super_block *sb, int *flags, char *data) |
86 | { |
87 | *flags |= MS_NOATIME; |
88 | return 0; |
89 | } |
90 | |
91 | /* exported operations */ |
92 | static const struct super_operations coda_super_operations = |
93 | { |
94 | .alloc_inode = coda_alloc_inode, |
95 | .destroy_inode = coda_destroy_inode, |
96 | .clear_inode = coda_clear_inode, |
97 | .put_super = coda_put_super, |
98 | .statfs = coda_statfs, |
99 | .remount_fs = coda_remount, |
100 | }; |
101 | |
102 | static int get_device_index(struct coda_mount_data *data) |
103 | { |
104 | struct file *file; |
105 | struct inode *inode; |
106 | int idx; |
107 | |
108 | if(data == NULL) { |
109 | printk("coda_read_super: Bad mount data\n"); |
110 | return -1; |
111 | } |
112 | |
113 | if(data->version != CODA_MOUNT_VERSION) { |
114 | printk("coda_read_super: Bad mount version\n"); |
115 | return -1; |
116 | } |
117 | |
118 | file = fget(data->fd); |
119 | inode = NULL; |
120 | if(file) |
121 | inode = file->f_path.dentry->d_inode; |
122 | |
123 | if(!inode || !S_ISCHR(inode->i_mode) || |
124 | imajor(inode) != CODA_PSDEV_MAJOR) { |
125 | if(file) |
126 | fput(file); |
127 | |
128 | printk("coda_read_super: Bad file\n"); |
129 | return -1; |
130 | } |
131 | |
132 | idx = iminor(inode); |
133 | fput(file); |
134 | |
135 | if(idx < 0 || idx >= MAX_CODADEVS) { |
136 | printk("coda_read_super: Bad minor number\n"); |
137 | return -1; |
138 | } |
139 | |
140 | return idx; |
141 | } |
142 | |
143 | static int coda_fill_super(struct super_block *sb, void *data, int silent) |
144 | { |
145 | struct inode *root = NULL; |
146 | struct venus_comm *vc = NULL; |
147 | struct CodaFid fid; |
148 | int error; |
149 | int idx; |
150 | |
151 | idx = get_device_index((struct coda_mount_data *) data); |
152 | |
153 | /* Ignore errors in data, for backward compatibility */ |
154 | if(idx == -1) |
155 | idx = 0; |
156 | |
157 | printk(KERN_INFO "coda_read_super: device index: %i\n", idx); |
158 | |
159 | vc = &coda_comms[idx]; |
160 | if (!vc->vc_inuse) { |
161 | printk("coda_read_super: No pseudo device\n"); |
162 | return -EINVAL; |
163 | } |
164 | |
165 | if ( vc->vc_sb ) { |
166 | printk("coda_read_super: Device already mounted\n"); |
167 | return -EBUSY; |
168 | } |
169 | |
170 | vc->vc_sb = sb; |
171 | |
172 | sb->s_fs_info = vc; |
173 | sb->s_flags |= MS_NOATIME; |
174 | sb->s_blocksize = 4096; /* XXXXX what do we put here?? */ |
175 | sb->s_blocksize_bits = 12; |
176 | sb->s_magic = CODA_SUPER_MAGIC; |
177 | sb->s_op = &coda_super_operations; |
178 | |
179 | /* get root fid from Venus: this needs the root inode */ |
180 | error = venus_rootfid(sb, &fid); |
181 | if ( error ) { |
182 | printk("coda_read_super: coda_get_rootfid failed with %d\n", |
183 | error); |
184 | goto error; |
185 | } |
186 | printk("coda_read_super: rootfid is %s\n", coda_f2s(&fid)); |
187 | |
188 | /* make root inode */ |
189 | error = coda_cnode_make(&root, &fid, sb); |
190 | if ( error || !root ) { |
191 | printk("Failure of coda_cnode_make for root: error %d\n", error); |
192 | goto error; |
193 | } |
194 | |
195 | printk("coda_read_super: rootinode is %ld dev %s\n", |
196 | root->i_ino, root->i_sb->s_id); |
197 | sb->s_root = d_alloc_root(root); |
198 | if (!sb->s_root) |
199 | goto error; |
200 | return 0; |
201 | |
202 | error: |
203 | if (root) |
204 | iput(root); |
205 | if (vc) |
206 | vc->vc_sb = NULL; |
207 | |
208 | return -EINVAL; |
209 | } |
210 | |
211 | static void coda_put_super(struct super_block *sb) |
212 | { |
213 | coda_vcp(sb)->vc_sb = NULL; |
214 | sb->s_fs_info = NULL; |
215 | |
216 | printk("Coda: Bye bye.\n"); |
217 | } |
218 | |
219 | static void coda_clear_inode(struct inode *inode) |
220 | { |
221 | coda_cache_clear_inode(inode); |
222 | } |
223 | |
224 | int coda_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) |
225 | { |
226 | int err = coda_revalidate_inode(dentry); |
227 | if (!err) |
228 | generic_fillattr(dentry->d_inode, stat); |
229 | return err; |
230 | } |
231 | |
232 | int coda_setattr(struct dentry *de, struct iattr *iattr) |
233 | { |
234 | struct inode *inode = de->d_inode; |
235 | struct coda_vattr vattr; |
236 | int error; |
237 | |
238 | lock_kernel(); |
239 | |
240 | memset(&vattr, 0, sizeof(vattr)); |
241 | |
242 | inode->i_ctime = CURRENT_TIME_SEC; |
243 | coda_iattr_to_vattr(iattr, &vattr); |
244 | vattr.va_type = C_VNON; /* cannot set type */ |
245 | |
246 | /* Venus is responsible for truncating the container-file!!! */ |
247 | error = venus_setattr(inode->i_sb, coda_i2f(inode), &vattr); |
248 | |
249 | if ( !error ) { |
250 | coda_vattr_to_iattr(inode, &vattr); |
251 | coda_cache_clear_inode(inode); |
252 | } |
253 | |
254 | unlock_kernel(); |
255 | |
256 | return error; |
257 | } |
258 | |
259 | const struct inode_operations coda_file_inode_operations = { |
260 | .permission = coda_permission, |
261 | .getattr = coda_getattr, |
262 | .setattr = coda_setattr, |
263 | }; |
264 | |
265 | static int coda_statfs(struct dentry *dentry, struct kstatfs *buf) |
266 | { |
267 | int error; |
268 | |
269 | lock_kernel(); |
270 | |
271 | error = venus_statfs(dentry, buf); |
272 | |
273 | unlock_kernel(); |
274 | |
275 | if (error) { |
276 | /* fake something like AFS does */ |
277 | buf->f_blocks = 9000000; |
278 | buf->f_bfree = 9000000; |
279 | buf->f_bavail = 9000000; |
280 | buf->f_files = 9000000; |
281 | buf->f_ffree = 9000000; |
282 | } |
283 | |
284 | /* and fill in the rest */ |
285 | buf->f_type = CODA_SUPER_MAGIC; |
286 | buf->f_bsize = 4096; |
287 | buf->f_namelen = CODA_MAXNAMLEN; |
288 | |
289 | return 0; |
290 | } |
291 | |
292 | /* init_coda: used by filesystems.c to register coda */ |
293 | |
294 | static int coda_get_sb(struct file_system_type *fs_type, |
295 | int flags, const char *dev_name, void *data, struct vfsmount *mnt) |
296 | { |
297 | return get_sb_nodev(fs_type, flags, data, coda_fill_super, mnt); |
298 | } |
299 | |
300 | struct file_system_type coda_fs_type = { |
301 | .owner = THIS_MODULE, |
302 | .name = "coda", |
303 | .get_sb = coda_get_sb, |
304 | .kill_sb = kill_anon_super, |
305 | .fs_flags = FS_BINARY_MOUNTDATA, |
306 | }; |
307 | |
308 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9