Commit | Line | Data |
---|---|---|
ec26815a DH |
1 | /* AFS superblock handling |
2 | * | |
08e0e7c8 | 3 | * Copyright (c) 2002, 2007 Red Hat, Inc. All rights reserved. |
1da177e4 LT |
4 | * |
5 | * This software may be freely redistributed under the terms of the | |
6 | * GNU General Public License. | |
7 | * | |
8 | * You should have received a copy of the GNU General Public License | |
9 | * along with this program; if not, write to the Free Software | |
10 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
11 | * | |
12 | * Authors: David Howells <dhowells@redhat.com> | |
44d1b980 | 13 | * David Woodhouse <dwmw2@infradead.org> |
1da177e4 LT |
14 | * |
15 | */ | |
16 | ||
17 | #include <linux/kernel.h> | |
18 | #include <linux/module.h> | |
19 | #include <linux/init.h> | |
20 | #include <linux/slab.h> | |
405f5571 | 21 | #include <linux/smp_lock.h> |
1da177e4 LT |
22 | #include <linux/fs.h> |
23 | #include <linux/pagemap.h> | |
80c72fe4 | 24 | #include <linux/parser.h> |
45222b9e | 25 | #include <linux/statfs.h> |
e8edc6e0 | 26 | #include <linux/sched.h> |
1da177e4 LT |
27 | #include "internal.h" |
28 | ||
29 | #define AFS_FS_MAGIC 0x6B414653 /* 'kAFS' */ | |
30 | ||
51cc5068 | 31 | static void afs_i_init_once(void *foo); |
454e2398 DH |
32 | static int afs_get_sb(struct file_system_type *fs_type, |
33 | int flags, const char *dev_name, | |
34 | void *data, struct vfsmount *mnt); | |
1da177e4 | 35 | static struct inode *afs_alloc_inode(struct super_block *sb); |
1da177e4 | 36 | static void afs_put_super(struct super_block *sb); |
1da177e4 | 37 | static void afs_destroy_inode(struct inode *inode); |
45222b9e | 38 | static int afs_statfs(struct dentry *dentry, struct kstatfs *buf); |
1da177e4 | 39 | |
1f5ce9e9 | 40 | struct file_system_type afs_fs_type = { |
1da177e4 LT |
41 | .owner = THIS_MODULE, |
42 | .name = "afs", | |
43 | .get_sb = afs_get_sb, | |
44 | .kill_sb = kill_anon_super, | |
80c72fe4 | 45 | .fs_flags = 0, |
1da177e4 LT |
46 | }; |
47 | ||
ee9b6d61 | 48 | static const struct super_operations afs_super_ops = { |
45222b9e | 49 | .statfs = afs_statfs, |
1da177e4 | 50 | .alloc_inode = afs_alloc_inode, |
1da177e4 LT |
51 | .destroy_inode = afs_destroy_inode, |
52 | .clear_inode = afs_clear_inode, | |
53 | .put_super = afs_put_super, | |
969729d5 | 54 | .show_options = generic_show_options, |
1da177e4 LT |
55 | }; |
56 | ||
e18b890b | 57 | static struct kmem_cache *afs_inode_cachep; |
1da177e4 LT |
58 | static atomic_t afs_count_active_inodes; |
59 | ||
80c72fe4 DH |
60 | enum { |
61 | afs_no_opt, | |
62 | afs_opt_cell, | |
63 | afs_opt_rwpath, | |
64 | afs_opt_vol, | |
65 | }; | |
66 | ||
a447c093 | 67 | static const match_table_t afs_options_list = { |
80c72fe4 DH |
68 | { afs_opt_cell, "cell=%s" }, |
69 | { afs_opt_rwpath, "rwpath" }, | |
70 | { afs_opt_vol, "vol=%s" }, | |
71 | { afs_no_opt, NULL }, | |
72 | }; | |
73 | ||
1da177e4 LT |
74 | /* |
75 | * initialise the filesystem | |
76 | */ | |
77 | int __init afs_fs_init(void) | |
78 | { | |
79 | int ret; | |
80 | ||
81 | _enter(""); | |
82 | ||
1da177e4 LT |
83 | /* create ourselves an inode cache */ |
84 | atomic_set(&afs_count_active_inodes, 0); | |
85 | ||
86 | ret = -ENOMEM; | |
87 | afs_inode_cachep = kmem_cache_create("afs_inode_cache", | |
88 | sizeof(struct afs_vnode), | |
89 | 0, | |
90 | SLAB_HWCACHE_ALIGN, | |
20c2df83 | 91 | afs_i_init_once); |
1da177e4 LT |
92 | if (!afs_inode_cachep) { |
93 | printk(KERN_NOTICE "kAFS: Failed to allocate inode cache\n"); | |
94 | return ret; | |
95 | } | |
96 | ||
97 | /* now export our filesystem to lesser mortals */ | |
98 | ret = register_filesystem(&afs_fs_type); | |
99 | if (ret < 0) { | |
100 | kmem_cache_destroy(afs_inode_cachep); | |
08e0e7c8 | 101 | _leave(" = %d", ret); |
1da177e4 LT |
102 | return ret; |
103 | } | |
104 | ||
08e0e7c8 | 105 | _leave(" = 0"); |
1da177e4 | 106 | return 0; |
ec26815a | 107 | } |
1da177e4 | 108 | |
1da177e4 LT |
109 | /* |
110 | * clean up the filesystem | |
111 | */ | |
112 | void __exit afs_fs_exit(void) | |
113 | { | |
08e0e7c8 DH |
114 | _enter(""); |
115 | ||
116 | afs_mntpt_kill_timer(); | |
1da177e4 LT |
117 | unregister_filesystem(&afs_fs_type); |
118 | ||
119 | if (atomic_read(&afs_count_active_inodes) != 0) { | |
120 | printk("kAFS: %d active inode objects still present\n", | |
121 | atomic_read(&afs_count_active_inodes)); | |
122 | BUG(); | |
123 | } | |
124 | ||
125 | kmem_cache_destroy(afs_inode_cachep); | |
08e0e7c8 | 126 | _leave(""); |
ec26815a | 127 | } |
1da177e4 | 128 | |
1da177e4 LT |
129 | /* |
130 | * parse the mount options | |
131 | * - this function has been shamelessly adapted from the ext3 fs which | |
132 | * shamelessly adapted it from the msdos fs | |
133 | */ | |
00d3b7a4 DH |
134 | static int afs_parse_options(struct afs_mount_params *params, |
135 | char *options, const char **devname) | |
1da177e4 | 136 | { |
08e0e7c8 | 137 | struct afs_cell *cell; |
80c72fe4 DH |
138 | substring_t args[MAX_OPT_ARGS]; |
139 | char *p; | |
140 | int token; | |
1da177e4 LT |
141 | |
142 | _enter("%s", options); | |
143 | ||
144 | options[PAGE_SIZE - 1] = 0; | |
145 | ||
80c72fe4 DH |
146 | while ((p = strsep(&options, ","))) { |
147 | if (!*p) | |
148 | continue; | |
1da177e4 | 149 | |
80c72fe4 DH |
150 | token = match_token(p, afs_options_list, args); |
151 | switch (token) { | |
152 | case afs_opt_cell: | |
153 | cell = afs_cell_lookup(args[0].from, | |
154 | args[0].to - args[0].from); | |
08e0e7c8 DH |
155 | if (IS_ERR(cell)) |
156 | return PTR_ERR(cell); | |
00d3b7a4 DH |
157 | afs_put_cell(params->cell); |
158 | params->cell = cell; | |
80c72fe4 DH |
159 | break; |
160 | ||
161 | case afs_opt_rwpath: | |
162 | params->rwpath = 1; | |
163 | break; | |
164 | ||
165 | case afs_opt_vol: | |
166 | *devname = args[0].from; | |
167 | break; | |
168 | ||
169 | default: | |
170 | printk(KERN_ERR "kAFS:" | |
171 | " Unknown or invalid mount option: '%s'\n", p); | |
172 | return -EINVAL; | |
1da177e4 | 173 | } |
1da177e4 LT |
174 | } |
175 | ||
80c72fe4 DH |
176 | _leave(" = 0"); |
177 | return 0; | |
ec26815a | 178 | } |
1da177e4 | 179 | |
00d3b7a4 DH |
180 | /* |
181 | * parse a device name to get cell name, volume name, volume type and R/W | |
182 | * selector | |
183 | * - this can be one of the following: | |
184 | * "%[cell:]volume[.]" R/W volume | |
185 | * "#[cell:]volume[.]" R/O or R/W volume (rwpath=0), | |
186 | * or R/W (rwpath=1) volume | |
187 | * "%[cell:]volume.readonly" R/O volume | |
188 | * "#[cell:]volume.readonly" R/O volume | |
189 | * "%[cell:]volume.backup" Backup volume | |
190 | * "#[cell:]volume.backup" Backup volume | |
191 | */ | |
192 | static int afs_parse_device_name(struct afs_mount_params *params, | |
193 | const char *name) | |
194 | { | |
195 | struct afs_cell *cell; | |
196 | const char *cellname, *suffix; | |
197 | int cellnamesz; | |
198 | ||
199 | _enter(",%s", name); | |
200 | ||
201 | if (!name) { | |
202 | printk(KERN_ERR "kAFS: no volume name specified\n"); | |
203 | return -EINVAL; | |
204 | } | |
205 | ||
206 | if ((name[0] != '%' && name[0] != '#') || !name[1]) { | |
207 | printk(KERN_ERR "kAFS: unparsable volume name\n"); | |
208 | return -EINVAL; | |
209 | } | |
210 | ||
211 | /* determine the type of volume we're looking for */ | |
212 | params->type = AFSVL_ROVOL; | |
213 | params->force = false; | |
214 | if (params->rwpath || name[0] == '%') { | |
215 | params->type = AFSVL_RWVOL; | |
216 | params->force = true; | |
217 | } | |
218 | name++; | |
219 | ||
220 | /* split the cell name out if there is one */ | |
221 | params->volname = strchr(name, ':'); | |
222 | if (params->volname) { | |
223 | cellname = name; | |
224 | cellnamesz = params->volname - name; | |
225 | params->volname++; | |
226 | } else { | |
227 | params->volname = name; | |
228 | cellname = NULL; | |
229 | cellnamesz = 0; | |
230 | } | |
231 | ||
232 | /* the volume type is further affected by a possible suffix */ | |
233 | suffix = strrchr(params->volname, '.'); | |
234 | if (suffix) { | |
235 | if (strcmp(suffix, ".readonly") == 0) { | |
236 | params->type = AFSVL_ROVOL; | |
237 | params->force = true; | |
238 | } else if (strcmp(suffix, ".backup") == 0) { | |
239 | params->type = AFSVL_BACKVOL; | |
240 | params->force = true; | |
241 | } else if (suffix[1] == 0) { | |
242 | } else { | |
243 | suffix = NULL; | |
244 | } | |
245 | } | |
246 | ||
247 | params->volnamesz = suffix ? | |
248 | suffix - params->volname : strlen(params->volname); | |
249 | ||
250 | _debug("cell %*.*s [%p]", | |
251 | cellnamesz, cellnamesz, cellname ?: "", params->cell); | |
252 | ||
253 | /* lookup the cell record */ | |
254 | if (cellname || !params->cell) { | |
255 | cell = afs_cell_lookup(cellname, cellnamesz); | |
256 | if (IS_ERR(cell)) { | |
257 | printk(KERN_ERR "kAFS: unable to lookup cell '%s'\n", | |
258 | cellname ?: ""); | |
259 | return PTR_ERR(cell); | |
260 | } | |
261 | afs_put_cell(params->cell); | |
262 | params->cell = cell; | |
263 | } | |
264 | ||
265 | _debug("CELL:%s [%p] VOLUME:%*.*s SUFFIX:%s TYPE:%d%s", | |
266 | params->cell->name, params->cell, | |
267 | params->volnamesz, params->volnamesz, params->volname, | |
268 | suffix ?: "-", params->type, params->force ? " FORCE" : ""); | |
269 | ||
270 | return 0; | |
271 | } | |
272 | ||
1da177e4 LT |
273 | /* |
274 | * check a superblock to see if it's the one we're looking for | |
275 | */ | |
276 | static int afs_test_super(struct super_block *sb, void *data) | |
277 | { | |
278 | struct afs_mount_params *params = data; | |
279 | struct afs_super_info *as = sb->s_fs_info; | |
280 | ||
281 | return as->volume == params->volume; | |
ec26815a | 282 | } |
1da177e4 | 283 | |
1da177e4 LT |
284 | /* |
285 | * fill in the superblock | |
286 | */ | |
436058a4 | 287 | static int afs_fill_super(struct super_block *sb, void *data) |
1da177e4 LT |
288 | { |
289 | struct afs_mount_params *params = data; | |
290 | struct afs_super_info *as = NULL; | |
291 | struct afs_fid fid; | |
292 | struct dentry *root = NULL; | |
293 | struct inode *inode = NULL; | |
294 | int ret; | |
295 | ||
08e0e7c8 | 296 | _enter(""); |
1da177e4 LT |
297 | |
298 | /* allocate a superblock info record */ | |
b593e48d | 299 | as = kzalloc(sizeof(struct afs_super_info), GFP_KERNEL); |
1da177e4 LT |
300 | if (!as) { |
301 | _leave(" = -ENOMEM"); | |
302 | return -ENOMEM; | |
303 | } | |
304 | ||
1da177e4 LT |
305 | afs_get_volume(params->volume); |
306 | as->volume = params->volume; | |
307 | ||
308 | /* fill in the superblock */ | |
309 | sb->s_blocksize = PAGE_CACHE_SIZE; | |
310 | sb->s_blocksize_bits = PAGE_CACHE_SHIFT; | |
311 | sb->s_magic = AFS_FS_MAGIC; | |
312 | sb->s_op = &afs_super_ops; | |
313 | sb->s_fs_info = as; | |
314 | ||
315 | /* allocate the root inode and dentry */ | |
316 | fid.vid = as->volume->vid; | |
317 | fid.vnode = 1; | |
318 | fid.unique = 1; | |
260a9803 | 319 | inode = afs_iget(sb, params->key, &fid, NULL, NULL); |
08e0e7c8 DH |
320 | if (IS_ERR(inode)) |
321 | goto error_inode; | |
1da177e4 LT |
322 | |
323 | ret = -ENOMEM; | |
324 | root = d_alloc_root(inode); | |
325 | if (!root) | |
326 | goto error; | |
327 | ||
328 | sb->s_root = root; | |
329 | ||
08e0e7c8 | 330 | _leave(" = 0"); |
1da177e4 LT |
331 | return 0; |
332 | ||
08e0e7c8 DH |
333 | error_inode: |
334 | ret = PTR_ERR(inode); | |
335 | inode = NULL; | |
ec26815a | 336 | error: |
1da177e4 LT |
337 | iput(inode); |
338 | afs_put_volume(as->volume); | |
339 | kfree(as); | |
340 | ||
341 | sb->s_fs_info = NULL; | |
342 | ||
08e0e7c8 | 343 | _leave(" = %d", ret); |
1da177e4 | 344 | return ret; |
ec26815a | 345 | } |
1da177e4 | 346 | |
1da177e4 LT |
347 | /* |
348 | * get an AFS superblock | |
1da177e4 | 349 | */ |
454e2398 DH |
350 | static int afs_get_sb(struct file_system_type *fs_type, |
351 | int flags, | |
352 | const char *dev_name, | |
353 | void *options, | |
354 | struct vfsmount *mnt) | |
1da177e4 LT |
355 | { |
356 | struct afs_mount_params params; | |
357 | struct super_block *sb; | |
08e0e7c8 | 358 | struct afs_volume *vol; |
00d3b7a4 | 359 | struct key *key; |
969729d5 | 360 | char *new_opts = kstrdup(options, GFP_KERNEL); |
1da177e4 LT |
361 | int ret; |
362 | ||
363 | _enter(",,%s,%p", dev_name, options); | |
364 | ||
365 | memset(¶ms, 0, sizeof(params)); | |
366 | ||
00d3b7a4 | 367 | /* parse the options and device name */ |
1da177e4 | 368 | if (options) { |
00d3b7a4 | 369 | ret = afs_parse_options(¶ms, options, &dev_name); |
1da177e4 LT |
370 | if (ret < 0) |
371 | goto error; | |
1da177e4 LT |
372 | } |
373 | ||
00d3b7a4 DH |
374 | ret = afs_parse_device_name(¶ms, dev_name); |
375 | if (ret < 0) | |
376 | goto error; | |
377 | ||
378 | /* try and do the mount securely */ | |
379 | key = afs_request_key(params.cell); | |
380 | if (IS_ERR(key)) { | |
381 | _leave(" = %ld [key]", PTR_ERR(key)); | |
382 | ret = PTR_ERR(key); | |
383 | goto error; | |
384 | } | |
385 | params.key = key; | |
386 | ||
1da177e4 | 387 | /* parse the device name */ |
00d3b7a4 | 388 | vol = afs_volume_lookup(¶ms); |
08e0e7c8 DH |
389 | if (IS_ERR(vol)) { |
390 | ret = PTR_ERR(vol); | |
1da177e4 | 391 | goto error; |
08e0e7c8 | 392 | } |
08e0e7c8 | 393 | params.volume = vol; |
1da177e4 LT |
394 | |
395 | /* allocate a deviceless superblock */ | |
396 | sb = sget(fs_type, afs_test_super, set_anon_super, ¶ms); | |
08e0e7c8 DH |
397 | if (IS_ERR(sb)) { |
398 | ret = PTR_ERR(sb); | |
1da177e4 | 399 | goto error; |
08e0e7c8 | 400 | } |
1da177e4 | 401 | |
436058a4 DH |
402 | if (!sb->s_root) { |
403 | /* initial superblock/root creation */ | |
404 | _debug("create"); | |
405 | sb->s_flags = flags; | |
406 | ret = afs_fill_super(sb, ¶ms); | |
407 | if (ret < 0) { | |
6f5bbff9 | 408 | deactivate_locked_super(sb); |
436058a4 DH |
409 | goto error; |
410 | } | |
2a32cebd | 411 | save_mount_options(sb, new_opts); |
436058a4 DH |
412 | sb->s_flags |= MS_ACTIVE; |
413 | } else { | |
414 | _debug("reuse"); | |
415 | ASSERTCMP(sb->s_flags, &, MS_ACTIVE); | |
1da177e4 | 416 | } |
1da177e4 | 417 | |
436058a4 | 418 | simple_set_mnt(mnt, sb); |
1da177e4 | 419 | afs_put_volume(params.volume); |
00d3b7a4 | 420 | afs_put_cell(params.cell); |
2a32cebd | 421 | kfree(new_opts); |
08e0e7c8 | 422 | _leave(" = 0 [%p]", sb); |
454e2398 | 423 | return 0; |
1da177e4 | 424 | |
ec26815a | 425 | error: |
1da177e4 | 426 | afs_put_volume(params.volume); |
00d3b7a4 DH |
427 | afs_put_cell(params.cell); |
428 | key_put(params.key); | |
969729d5 | 429 | kfree(new_opts); |
1da177e4 | 430 | _leave(" = %d", ret); |
454e2398 | 431 | return ret; |
ec26815a | 432 | } |
1da177e4 | 433 | |
1da177e4 LT |
434 | /* |
435 | * finish the unmounting process on the superblock | |
436 | */ | |
437 | static void afs_put_super(struct super_block *sb) | |
438 | { | |
439 | struct afs_super_info *as = sb->s_fs_info; | |
440 | ||
441 | _enter(""); | |
442 | ||
6cfd0148 CH |
443 | lock_kernel(); |
444 | ||
1da177e4 | 445 | afs_put_volume(as->volume); |
1da177e4 | 446 | |
6cfd0148 CH |
447 | unlock_kernel(); |
448 | ||
1da177e4 | 449 | _leave(""); |
ec26815a | 450 | } |
1da177e4 | 451 | |
1da177e4 LT |
452 | /* |
453 | * initialise an inode cache slab element prior to any use | |
454 | */ | |
51cc5068 | 455 | static void afs_i_init_once(void *_vnode) |
1da177e4 | 456 | { |
ec26815a | 457 | struct afs_vnode *vnode = _vnode; |
1da177e4 | 458 | |
a35afb83 CL |
459 | memset(vnode, 0, sizeof(*vnode)); |
460 | inode_init_once(&vnode->vfs_inode); | |
461 | init_waitqueue_head(&vnode->update_waitq); | |
462 | mutex_init(&vnode->permits_lock); | |
463 | mutex_init(&vnode->validate_lock); | |
464 | spin_lock_init(&vnode->writeback_lock); | |
465 | spin_lock_init(&vnode->lock); | |
466 | INIT_LIST_HEAD(&vnode->writebacks); | |
e8d6c554 DH |
467 | INIT_LIST_HEAD(&vnode->pending_locks); |
468 | INIT_LIST_HEAD(&vnode->granted_locks); | |
469 | INIT_DELAYED_WORK(&vnode->lock_work, afs_lock_work); | |
a35afb83 | 470 | INIT_WORK(&vnode->cb_broken_work, afs_broken_callback_work); |
ec26815a | 471 | } |
1da177e4 | 472 | |
1da177e4 LT |
473 | /* |
474 | * allocate an AFS inode struct from our slab cache | |
475 | */ | |
476 | static struct inode *afs_alloc_inode(struct super_block *sb) | |
477 | { | |
478 | struct afs_vnode *vnode; | |
479 | ||
ec26815a | 480 | vnode = kmem_cache_alloc(afs_inode_cachep, GFP_KERNEL); |
1da177e4 LT |
481 | if (!vnode) |
482 | return NULL; | |
483 | ||
484 | atomic_inc(&afs_count_active_inodes); | |
485 | ||
486 | memset(&vnode->fid, 0, sizeof(vnode->fid)); | |
487 | memset(&vnode->status, 0, sizeof(vnode->status)); | |
488 | ||
489 | vnode->volume = NULL; | |
490 | vnode->update_cnt = 0; | |
260a9803 | 491 | vnode->flags = 1 << AFS_VNODE_UNSET; |
08e0e7c8 | 492 | vnode->cb_promised = false; |
1da177e4 | 493 | |
0f300ca9 | 494 | _leave(" = %p", &vnode->vfs_inode); |
1da177e4 | 495 | return &vnode->vfs_inode; |
ec26815a | 496 | } |
1da177e4 | 497 | |
1da177e4 LT |
498 | /* |
499 | * destroy an AFS inode struct | |
500 | */ | |
501 | static void afs_destroy_inode(struct inode *inode) | |
502 | { | |
08e0e7c8 DH |
503 | struct afs_vnode *vnode = AFS_FS_I(inode); |
504 | ||
0f300ca9 | 505 | _enter("%p{%x:%u}", inode, vnode->fid.vid, vnode->fid.vnode); |
1da177e4 | 506 | |
08e0e7c8 DH |
507 | _debug("DESTROY INODE %p", inode); |
508 | ||
509 | ASSERTCMP(vnode->server, ==, NULL); | |
510 | ||
511 | kmem_cache_free(afs_inode_cachep, vnode); | |
1da177e4 | 512 | atomic_dec(&afs_count_active_inodes); |
ec26815a | 513 | } |
45222b9e DH |
514 | |
515 | /* | |
516 | * return information about an AFS volume | |
517 | */ | |
518 | static int afs_statfs(struct dentry *dentry, struct kstatfs *buf) | |
519 | { | |
520 | struct afs_volume_status vs; | |
521 | struct afs_vnode *vnode = AFS_FS_I(dentry->d_inode); | |
522 | struct key *key; | |
523 | int ret; | |
524 | ||
525 | key = afs_request_key(vnode->volume->cell); | |
526 | if (IS_ERR(key)) | |
527 | return PTR_ERR(key); | |
528 | ||
529 | ret = afs_vnode_get_volume_status(vnode, key, &vs); | |
530 | key_put(key); | |
531 | if (ret < 0) { | |
532 | _leave(" = %d", ret); | |
533 | return ret; | |
534 | } | |
535 | ||
536 | buf->f_type = dentry->d_sb->s_magic; | |
537 | buf->f_bsize = AFS_BLOCK_SIZE; | |
538 | buf->f_namelen = AFSNAMEMAX - 1; | |
539 | ||
540 | if (vs.max_quota == 0) | |
541 | buf->f_blocks = vs.part_max_blocks; | |
542 | else | |
543 | buf->f_blocks = vs.max_quota; | |
544 | buf->f_bavail = buf->f_bfree = buf->f_blocks - vs.blocks_in_use; | |
545 | return 0; | |
546 | } |