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