Commit | Line | Data |
---|---|---|
ec26815a DH |
1 | /* AFS superblock handling |
2 | * | |
13fcc683 | 3 | * Copyright (c) 2002, 2007, 2018 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> | |
bec5eb61 | 19 | #include <linux/mount.h> |
1da177e4 LT |
20 | #include <linux/init.h> |
21 | #include <linux/slab.h> | |
22 | #include <linux/fs.h> | |
23 | #include <linux/pagemap.h> | |
13fcc683 | 24 | #include <linux/fs_parser.h> |
45222b9e | 25 | #include <linux/statfs.h> |
e8edc6e0 | 26 | #include <linux/sched.h> |
f74f70f8 | 27 | #include <linux/nsproxy.h> |
f044c884 | 28 | #include <linux/magic.h> |
f74f70f8 | 29 | #include <net/net_namespace.h> |
1da177e4 LT |
30 | #include "internal.h" |
31 | ||
51cc5068 | 32 | static void afs_i_init_once(void *foo); |
dde194a6 | 33 | static void afs_kill_super(struct super_block *sb); |
1da177e4 | 34 | static struct inode *afs_alloc_inode(struct super_block *sb); |
1da177e4 | 35 | static void afs_destroy_inode(struct inode *inode); |
45222b9e | 36 | static int afs_statfs(struct dentry *dentry, struct kstatfs *buf); |
677018a6 DH |
37 | static int afs_show_devname(struct seq_file *m, struct dentry *root); |
38 | static int afs_show_options(struct seq_file *m, struct dentry *root); | |
13fcc683 DH |
39 | static int afs_init_fs_context(struct fs_context *fc); |
40 | static const struct fs_parameter_description afs_fs_parameters; | |
1da177e4 | 41 | |
1f5ce9e9 | 42 | struct file_system_type afs_fs_type = { |
13fcc683 DH |
43 | .owner = THIS_MODULE, |
44 | .name = "afs", | |
45 | .init_fs_context = afs_init_fs_context, | |
46 | .parameters = &afs_fs_parameters, | |
47 | .kill_sb = afs_kill_super, | |
48 | .fs_flags = 0, | |
1da177e4 | 49 | }; |
7f78e035 | 50 | MODULE_ALIAS_FS("afs"); |
1da177e4 | 51 | |
5b86d4ff DH |
52 | int afs_net_id; |
53 | ||
ee9b6d61 | 54 | static const struct super_operations afs_super_ops = { |
45222b9e | 55 | .statfs = afs_statfs, |
1da177e4 | 56 | .alloc_inode = afs_alloc_inode, |
bec5eb61 | 57 | .drop_inode = afs_drop_inode, |
1da177e4 | 58 | .destroy_inode = afs_destroy_inode, |
b57922d9 | 59 | .evict_inode = afs_evict_inode, |
677018a6 DH |
60 | .show_devname = afs_show_devname, |
61 | .show_options = afs_show_options, | |
1da177e4 LT |
62 | }; |
63 | ||
e18b890b | 64 | static struct kmem_cache *afs_inode_cachep; |
1da177e4 LT |
65 | static atomic_t afs_count_active_inodes; |
66 | ||
13fcc683 DH |
67 | enum afs_param { |
68 | Opt_autocell, | |
69 | Opt_cell, | |
70 | Opt_dyn, | |
71 | Opt_rwpath, | |
72 | Opt_source, | |
73 | Opt_vol, | |
80c72fe4 DH |
74 | }; |
75 | ||
13fcc683 DH |
76 | static const struct fs_parameter_spec afs_param_specs[] = { |
77 | fsparam_flag ("autocell", Opt_autocell), | |
78 | fsparam_string("cell", Opt_cell), | |
79 | fsparam_flag ("dyn", Opt_dyn), | |
80 | fsparam_flag ("rwpath", Opt_rwpath), | |
81 | fsparam_string("source", Opt_source), | |
82 | fsparam_string("vol", Opt_vol), | |
83 | {} | |
84 | }; | |
85 | ||
86 | static const struct fs_parameter_description afs_fs_parameters = { | |
87 | .name = "kAFS", | |
88 | .specs = afs_param_specs, | |
80c72fe4 DH |
89 | }; |
90 | ||
1da177e4 LT |
91 | /* |
92 | * initialise the filesystem | |
93 | */ | |
94 | int __init afs_fs_init(void) | |
95 | { | |
96 | int ret; | |
97 | ||
98 | _enter(""); | |
99 | ||
1da177e4 LT |
100 | /* create ourselves an inode cache */ |
101 | atomic_set(&afs_count_active_inodes, 0); | |
102 | ||
103 | ret = -ENOMEM; | |
104 | afs_inode_cachep = kmem_cache_create("afs_inode_cache", | |
105 | sizeof(struct afs_vnode), | |
106 | 0, | |
5d097056 | 107 | SLAB_HWCACHE_ALIGN|SLAB_ACCOUNT, |
20c2df83 | 108 | afs_i_init_once); |
1da177e4 LT |
109 | if (!afs_inode_cachep) { |
110 | printk(KERN_NOTICE "kAFS: Failed to allocate inode cache\n"); | |
111 | return ret; | |
112 | } | |
113 | ||
114 | /* now export our filesystem to lesser mortals */ | |
115 | ret = register_filesystem(&afs_fs_type); | |
116 | if (ret < 0) { | |
117 | kmem_cache_destroy(afs_inode_cachep); | |
08e0e7c8 | 118 | _leave(" = %d", ret); |
1da177e4 LT |
119 | return ret; |
120 | } | |
121 | ||
08e0e7c8 | 122 | _leave(" = 0"); |
1da177e4 | 123 | return 0; |
ec26815a | 124 | } |
1da177e4 | 125 | |
1da177e4 LT |
126 | /* |
127 | * clean up the filesystem | |
128 | */ | |
5b86d4ff | 129 | void afs_fs_exit(void) |
1da177e4 | 130 | { |
08e0e7c8 DH |
131 | _enter(""); |
132 | ||
133 | afs_mntpt_kill_timer(); | |
1da177e4 LT |
134 | unregister_filesystem(&afs_fs_type); |
135 | ||
136 | if (atomic_read(&afs_count_active_inodes) != 0) { | |
137 | printk("kAFS: %d active inode objects still present\n", | |
138 | atomic_read(&afs_count_active_inodes)); | |
139 | BUG(); | |
140 | } | |
141 | ||
8c0a8537 KS |
142 | /* |
143 | * Make sure all delayed rcu free inodes are flushed before we | |
144 | * destroy cache. | |
145 | */ | |
146 | rcu_barrier(); | |
1da177e4 | 147 | kmem_cache_destroy(afs_inode_cachep); |
08e0e7c8 | 148 | _leave(""); |
ec26815a | 149 | } |
1da177e4 | 150 | |
677018a6 DH |
151 | /* |
152 | * Display the mount device name in /proc/mounts. | |
153 | */ | |
154 | static int afs_show_devname(struct seq_file *m, struct dentry *root) | |
155 | { | |
d2ddc776 | 156 | struct afs_super_info *as = AFS_FS_S(root->d_sb); |
677018a6 | 157 | struct afs_volume *volume = as->volume; |
d2ddc776 | 158 | struct afs_cell *cell = as->cell; |
677018a6 DH |
159 | const char *suf = ""; |
160 | char pref = '%'; | |
161 | ||
4d673da1 DH |
162 | if (as->dyn_root) { |
163 | seq_puts(m, "none"); | |
164 | return 0; | |
165 | } | |
66c7e1d3 | 166 | |
677018a6 DH |
167 | switch (volume->type) { |
168 | case AFSVL_RWVOL: | |
169 | break; | |
170 | case AFSVL_ROVOL: | |
171 | pref = '#'; | |
172 | if (volume->type_force) | |
173 | suf = ".readonly"; | |
174 | break; | |
175 | case AFSVL_BACKVOL: | |
176 | pref = '#'; | |
177 | suf = ".backup"; | |
178 | break; | |
179 | } | |
180 | ||
d2ddc776 | 181 | seq_printf(m, "%c%s:%s%s", pref, cell->name, volume->name, suf); |
677018a6 DH |
182 | return 0; |
183 | } | |
184 | ||
185 | /* | |
186 | * Display the mount options in /proc/mounts. | |
187 | */ | |
188 | static int afs_show_options(struct seq_file *m, struct dentry *root) | |
189 | { | |
4d673da1 DH |
190 | struct afs_super_info *as = AFS_FS_S(root->d_sb); |
191 | ||
192 | if (as->dyn_root) | |
193 | seq_puts(m, ",dyn"); | |
677018a6 | 194 | if (test_bit(AFS_VNODE_AUTOCELL, &AFS_FS_I(d_inode(root))->flags)) |
4d673da1 | 195 | seq_puts(m, ",autocell"); |
677018a6 DH |
196 | return 0; |
197 | } | |
198 | ||
1da177e4 | 199 | /* |
13fcc683 DH |
200 | * Parse the source name to get cell name, volume name, volume type and R/W |
201 | * selector. | |
202 | * | |
203 | * This can be one of the following: | |
00d3b7a4 DH |
204 | * "%[cell:]volume[.]" R/W volume |
205 | * "#[cell:]volume[.]" R/O or R/W volume (rwpath=0), | |
206 | * or R/W (rwpath=1) volume | |
207 | * "%[cell:]volume.readonly" R/O volume | |
208 | * "#[cell:]volume.readonly" R/O volume | |
209 | * "%[cell:]volume.backup" Backup volume | |
210 | * "#[cell:]volume.backup" Backup volume | |
211 | */ | |
13fcc683 | 212 | static int afs_parse_source(struct fs_context *fc, struct fs_parameter *param) |
00d3b7a4 | 213 | { |
13fcc683 | 214 | struct afs_fs_context *ctx = fc->fs_private; |
00d3b7a4 | 215 | struct afs_cell *cell; |
13fcc683 | 216 | const char *cellname, *suffix, *name = param->string; |
00d3b7a4 DH |
217 | int cellnamesz; |
218 | ||
219 | _enter(",%s", name); | |
66c7e1d3 | 220 | |
00d3b7a4 DH |
221 | if (!name) { |
222 | printk(KERN_ERR "kAFS: no volume name specified\n"); | |
223 | return -EINVAL; | |
224 | } | |
225 | ||
226 | if ((name[0] != '%' && name[0] != '#') || !name[1]) { | |
13fcc683 DH |
227 | /* To use dynroot, we don't want to have to provide a source */ |
228 | if (strcmp(name, "none") == 0) { | |
229 | ctx->no_cell = true; | |
230 | return 0; | |
231 | } | |
00d3b7a4 DH |
232 | printk(KERN_ERR "kAFS: unparsable volume name\n"); |
233 | return -EINVAL; | |
234 | } | |
235 | ||
236 | /* determine the type of volume we're looking for */ | |
13fcc683 DH |
237 | ctx->type = AFSVL_ROVOL; |
238 | ctx->force = false; | |
239 | if (ctx->rwpath || name[0] == '%') { | |
240 | ctx->type = AFSVL_RWVOL; | |
241 | ctx->force = true; | |
00d3b7a4 DH |
242 | } |
243 | name++; | |
244 | ||
245 | /* split the cell name out if there is one */ | |
13fcc683 DH |
246 | ctx->volname = strchr(name, ':'); |
247 | if (ctx->volname) { | |
00d3b7a4 | 248 | cellname = name; |
13fcc683 DH |
249 | cellnamesz = ctx->volname - name; |
250 | ctx->volname++; | |
00d3b7a4 | 251 | } else { |
13fcc683 | 252 | ctx->volname = name; |
00d3b7a4 DH |
253 | cellname = NULL; |
254 | cellnamesz = 0; | |
255 | } | |
256 | ||
257 | /* the volume type is further affected by a possible suffix */ | |
13fcc683 | 258 | suffix = strrchr(ctx->volname, '.'); |
00d3b7a4 DH |
259 | if (suffix) { |
260 | if (strcmp(suffix, ".readonly") == 0) { | |
13fcc683 DH |
261 | ctx->type = AFSVL_ROVOL; |
262 | ctx->force = true; | |
00d3b7a4 | 263 | } else if (strcmp(suffix, ".backup") == 0) { |
13fcc683 DH |
264 | ctx->type = AFSVL_BACKVOL; |
265 | ctx->force = true; | |
00d3b7a4 DH |
266 | } else if (suffix[1] == 0) { |
267 | } else { | |
268 | suffix = NULL; | |
269 | } | |
270 | } | |
271 | ||
13fcc683 DH |
272 | ctx->volnamesz = suffix ? |
273 | suffix - ctx->volname : strlen(ctx->volname); | |
00d3b7a4 DH |
274 | |
275 | _debug("cell %*.*s [%p]", | |
13fcc683 | 276 | cellnamesz, cellnamesz, cellname ?: "", ctx->cell); |
00d3b7a4 DH |
277 | |
278 | /* lookup the cell record */ | |
13fcc683 DH |
279 | if (cellname) { |
280 | cell = afs_lookup_cell(ctx->net, cellname, cellnamesz, | |
989782dc | 281 | NULL, false); |
00d3b7a4 | 282 | if (IS_ERR(cell)) { |
13fcc683 | 283 | pr_err("kAFS: unable to lookup cell '%*.*s'\n", |
bec5eb61 | 284 | cellnamesz, cellnamesz, cellname ?: ""); |
00d3b7a4 DH |
285 | return PTR_ERR(cell); |
286 | } | |
13fcc683 DH |
287 | afs_put_cell(ctx->net, ctx->cell); |
288 | ctx->cell = cell; | |
00d3b7a4 DH |
289 | } |
290 | ||
291 | _debug("CELL:%s [%p] VOLUME:%*.*s SUFFIX:%s TYPE:%d%s", | |
13fcc683 DH |
292 | ctx->cell->name, ctx->cell, |
293 | ctx->volnamesz, ctx->volnamesz, ctx->volname, | |
294 | suffix ?: "-", ctx->type, ctx->force ? " FORCE" : ""); | |
295 | ||
296 | fc->source = param->string; | |
297 | param->string = NULL; | |
298 | return 0; | |
299 | } | |
300 | ||
301 | /* | |
302 | * Parse a single mount parameter. | |
303 | */ | |
304 | static int afs_parse_param(struct fs_context *fc, struct fs_parameter *param) | |
305 | { | |
306 | struct fs_parse_result result; | |
307 | struct afs_fs_context *ctx = fc->fs_private; | |
308 | struct afs_cell *cell; | |
309 | int opt; | |
310 | ||
311 | opt = fs_parse(fc, &afs_fs_parameters, param, &result); | |
312 | if (opt < 0) | |
313 | return opt; | |
314 | ||
315 | switch (opt) { | |
316 | case Opt_cell: | |
317 | if (param->size <= 0) | |
318 | return -EINVAL; | |
319 | if (param->size > AFS_MAXCELLNAME) | |
320 | return -ENAMETOOLONG; | |
321 | ||
322 | rcu_read_lock(); | |
323 | cell = afs_lookup_cell_rcu(ctx->net, param->string, param->size); | |
324 | rcu_read_unlock(); | |
325 | if (IS_ERR(cell)) | |
326 | return PTR_ERR(cell); | |
327 | afs_put_cell(ctx->net, ctx->cell); | |
328 | ctx->cell = cell; | |
329 | break; | |
330 | ||
331 | case Opt_source: | |
332 | return afs_parse_source(fc, param); | |
333 | ||
334 | case Opt_autocell: | |
335 | ctx->autocell = true; | |
336 | break; | |
337 | ||
338 | case Opt_dyn: | |
339 | ctx->dyn_root = true; | |
340 | break; | |
341 | ||
342 | case Opt_rwpath: | |
343 | ctx->rwpath = true; | |
344 | break; | |
345 | ||
346 | case Opt_vol: | |
347 | return invalf(fc, "'vol' param is obsolete"); | |
348 | ||
349 | default: | |
350 | return -EINVAL; | |
351 | } | |
352 | ||
353 | _leave(" = 0"); | |
354 | return 0; | |
355 | } | |
356 | ||
357 | /* | |
358 | * Validate the options, get the cell key and look up the volume. | |
359 | */ | |
360 | static int afs_validate_fc(struct fs_context *fc) | |
361 | { | |
362 | struct afs_fs_context *ctx = fc->fs_private; | |
363 | struct afs_volume *volume; | |
364 | struct key *key; | |
365 | ||
366 | if (!ctx->dyn_root) { | |
367 | if (ctx->no_cell) { | |
368 | pr_warn("kAFS: Can only specify source 'none' with -o dyn\n"); | |
369 | return -EINVAL; | |
370 | } | |
371 | ||
372 | if (!ctx->cell) { | |
373 | pr_warn("kAFS: No cell specified\n"); | |
374 | return -EDESTADDRREQ; | |
375 | } | |
376 | ||
377 | /* We try to do the mount securely. */ | |
378 | key = afs_request_key(ctx->cell); | |
379 | if (IS_ERR(key)) | |
380 | return PTR_ERR(key); | |
381 | ||
382 | ctx->key = key; | |
383 | ||
384 | if (ctx->volume) { | |
385 | afs_put_volume(ctx->cell, ctx->volume); | |
386 | ctx->volume = NULL; | |
387 | } | |
388 | ||
389 | volume = afs_create_volume(ctx); | |
390 | if (IS_ERR(volume)) | |
391 | return PTR_ERR(volume); | |
392 | ||
393 | ctx->volume = volume; | |
394 | } | |
00d3b7a4 DH |
395 | |
396 | return 0; | |
397 | } | |
398 | ||
1da177e4 LT |
399 | /* |
400 | * check a superblock to see if it's the one we're looking for | |
401 | */ | |
13fcc683 | 402 | static int afs_test_super(struct super_block *sb, struct fs_context *fc) |
1da177e4 | 403 | { |
13fcc683 | 404 | struct afs_fs_context *ctx = fc->fs_private; |
d2ddc776 | 405 | struct afs_super_info *as = AFS_FS_S(sb); |
1da177e4 | 406 | |
13fcc683 | 407 | return (as->net_ns == fc->net_ns && |
4d673da1 | 408 | as->volume && |
13fcc683 | 409 | as->volume->vid == ctx->volume->vid && |
0da0b7fd | 410 | !as->dyn_root); |
4d673da1 DH |
411 | } |
412 | ||
13fcc683 | 413 | static int afs_dynroot_test_super(struct super_block *sb, struct fs_context *fc) |
4d673da1 | 414 | { |
0da0b7fd DH |
415 | struct afs_super_info *as = AFS_FS_S(sb); |
416 | ||
13fcc683 | 417 | return (as->net_ns == fc->net_ns && |
0da0b7fd | 418 | as->dyn_root); |
dde194a6 AV |
419 | } |
420 | ||
13fcc683 | 421 | static int afs_set_super(struct super_block *sb, struct fs_context *fc) |
dde194a6 | 422 | { |
dde194a6 | 423 | return set_anon_super(sb, NULL); |
ec26815a | 424 | } |
1da177e4 | 425 | |
1da177e4 LT |
426 | /* |
427 | * fill in the superblock | |
428 | */ | |
13fcc683 | 429 | static int afs_fill_super(struct super_block *sb, struct afs_fs_context *ctx) |
1da177e4 | 430 | { |
d2ddc776 | 431 | struct afs_super_info *as = AFS_FS_S(sb); |
1da177e4 | 432 | struct afs_fid fid; |
1da177e4 LT |
433 | struct inode *inode = NULL; |
434 | int ret; | |
435 | ||
08e0e7c8 | 436 | _enter(""); |
1da177e4 | 437 | |
1da177e4 | 438 | /* fill in the superblock */ |
09cbfeaf KS |
439 | sb->s_blocksize = PAGE_SIZE; |
440 | sb->s_blocksize_bits = PAGE_SHIFT; | |
1da177e4 LT |
441 | sb->s_magic = AFS_FS_MAGIC; |
442 | sb->s_op = &afs_super_ops; | |
4d673da1 DH |
443 | if (!as->dyn_root) |
444 | sb->s_xattr = afs_xattr_handlers; | |
edd3ba94 JK |
445 | ret = super_setup_bdi(sb); |
446 | if (ret) | |
447 | return ret; | |
448 | sb->s_bdi->ra_pages = VM_MAX_READAHEAD * 1024 / PAGE_SIZE; | |
1da177e4 LT |
449 | |
450 | /* allocate the root inode and dentry */ | |
4d673da1 DH |
451 | if (as->dyn_root) { |
452 | inode = afs_iget_pseudo_dir(sb, true); | |
453 | sb->s_flags |= SB_RDONLY; | |
454 | } else { | |
3b6492df | 455 | sprintf(sb->s_id, "%llu", as->volume->vid); |
4d673da1 DH |
456 | afs_activate_volume(as->volume); |
457 | fid.vid = as->volume->vid; | |
458 | fid.vnode = 1; | |
3b6492df | 459 | fid.vnode_hi = 0; |
4d673da1 | 460 | fid.unique = 1; |
13fcc683 | 461 | inode = afs_iget(sb, ctx->key, &fid, NULL, NULL, NULL); |
4d673da1 DH |
462 | } |
463 | ||
08e0e7c8 | 464 | if (IS_ERR(inode)) |
dde194a6 | 465 | return PTR_ERR(inode); |
1da177e4 | 466 | |
13fcc683 | 467 | if (ctx->autocell || as->dyn_root) |
bec5eb61 | 468 | set_bit(AFS_VNODE_AUTOCELL, &AFS_FS_I(inode)->flags); |
469 | ||
1da177e4 | 470 | ret = -ENOMEM; |
48fde701 AV |
471 | sb->s_root = d_make_root(inode); |
472 | if (!sb->s_root) | |
1da177e4 LT |
473 | goto error; |
474 | ||
0da0b7fd | 475 | if (as->dyn_root) { |
66c7e1d3 | 476 | sb->s_d_op = &afs_dynroot_dentry_operations; |
0da0b7fd DH |
477 | ret = afs_dynroot_populate(sb); |
478 | if (ret < 0) | |
479 | goto error; | |
480 | } else { | |
66c7e1d3 | 481 | sb->s_d_op = &afs_fs_dentry_operations; |
0da0b7fd | 482 | } |
1da177e4 | 483 | |
08e0e7c8 | 484 | _leave(" = 0"); |
1da177e4 LT |
485 | return 0; |
486 | ||
ec26815a | 487 | error: |
08e0e7c8 | 488 | _leave(" = %d", ret); |
1da177e4 | 489 | return ret; |
ec26815a | 490 | } |
1da177e4 | 491 | |
13fcc683 | 492 | static struct afs_super_info *afs_alloc_sbi(struct fs_context *fc) |
49566f6f | 493 | { |
13fcc683 | 494 | struct afs_fs_context *ctx = fc->fs_private; |
49566f6f DH |
495 | struct afs_super_info *as; |
496 | ||
497 | as = kzalloc(sizeof(struct afs_super_info), GFP_KERNEL); | |
498 | if (as) { | |
13fcc683 DH |
499 | as->net_ns = get_net(fc->net_ns); |
500 | if (ctx->dyn_root) { | |
4d673da1 | 501 | as->dyn_root = true; |
13fcc683 DH |
502 | } else { |
503 | as->cell = afs_get_cell(ctx->cell); | |
504 | as->volume = __afs_get_volume(ctx->volume); | |
505 | } | |
49566f6f DH |
506 | } |
507 | return as; | |
508 | } | |
509 | ||
510 | static void afs_destroy_sbi(struct afs_super_info *as) | |
511 | { | |
512 | if (as) { | |
9ed900b1 | 513 | afs_put_volume(as->cell, as->volume); |
5b86d4ff DH |
514 | afs_put_cell(afs_net(as->net_ns), as->cell); |
515 | put_net(as->net_ns); | |
49566f6f DH |
516 | kfree(as); |
517 | } | |
518 | } | |
519 | ||
0da0b7fd DH |
520 | static void afs_kill_super(struct super_block *sb) |
521 | { | |
522 | struct afs_super_info *as = AFS_FS_S(sb); | |
523 | struct afs_net *net = afs_net(as->net_ns); | |
524 | ||
525 | if (as->dyn_root) | |
526 | afs_dynroot_depopulate(sb); | |
13fcc683 | 527 | |
0da0b7fd DH |
528 | /* Clear the callback interests (which will do ilookup5) before |
529 | * deactivating the superblock. | |
530 | */ | |
531 | if (as->volume) | |
532 | afs_clear_callback_interests(net, as->volume->servers); | |
533 | kill_anon_super(sb); | |
534 | if (as->volume) | |
535 | afs_deactivate_volume(as->volume); | |
536 | afs_destroy_sbi(as); | |
537 | } | |
538 | ||
1da177e4 | 539 | /* |
13fcc683 | 540 | * Get an AFS superblock and root directory. |
1da177e4 | 541 | */ |
13fcc683 | 542 | static int afs_get_tree(struct fs_context *fc) |
1da177e4 | 543 | { |
13fcc683 | 544 | struct afs_fs_context *ctx = fc->fs_private; |
1da177e4 | 545 | struct super_block *sb; |
dde194a6 | 546 | struct afs_super_info *as; |
1da177e4 LT |
547 | int ret; |
548 | ||
13fcc683 DH |
549 | ret = afs_validate_fc(fc); |
550 | if (ret) | |
f74f70f8 | 551 | goto error; |
1da177e4 | 552 | |
13fcc683 | 553 | _enter(""); |
00d3b7a4 | 554 | |
49566f6f DH |
555 | /* allocate a superblock info record */ |
556 | ret = -ENOMEM; | |
13fcc683 | 557 | as = afs_alloc_sbi(fc); |
49566f6f | 558 | if (!as) |
13fcc683 DH |
559 | goto error; |
560 | fc->s_fs_info = as; | |
1da177e4 LT |
561 | |
562 | /* allocate a deviceless superblock */ | |
13fcc683 DH |
563 | sb = sget_fc(fc, |
564 | as->dyn_root ? afs_dynroot_test_super : afs_test_super, | |
565 | afs_set_super); | |
08e0e7c8 DH |
566 | if (IS_ERR(sb)) { |
567 | ret = PTR_ERR(sb); | |
13fcc683 | 568 | goto error; |
08e0e7c8 | 569 | } |
1da177e4 | 570 | |
436058a4 DH |
571 | if (!sb->s_root) { |
572 | /* initial superblock/root creation */ | |
573 | _debug("create"); | |
13fcc683 | 574 | ret = afs_fill_super(sb, ctx); |
f044c884 DH |
575 | if (ret < 0) |
576 | goto error_sb; | |
1751e8a6 | 577 | sb->s_flags |= SB_ACTIVE; |
436058a4 DH |
578 | } else { |
579 | _debug("reuse"); | |
1751e8a6 | 580 | ASSERTCMP(sb->s_flags, &, SB_ACTIVE); |
1da177e4 | 581 | } |
1da177e4 | 582 | |
13fcc683 | 583 | fc->root = dget(sb->s_root); |
08e0e7c8 | 584 | _leave(" = 0 [%p]", sb); |
13fcc683 | 585 | return 0; |
1da177e4 | 586 | |
f044c884 DH |
587 | error_sb: |
588 | deactivate_locked_super(sb); | |
ec26815a | 589 | error: |
1da177e4 | 590 | _leave(" = %d", ret); |
13fcc683 DH |
591 | return ret; |
592 | } | |
593 | ||
594 | static void afs_free_fc(struct fs_context *fc) | |
595 | { | |
596 | struct afs_fs_context *ctx = fc->fs_private; | |
597 | ||
598 | afs_destroy_sbi(fc->s_fs_info); | |
599 | afs_put_volume(ctx->cell, ctx->volume); | |
600 | afs_put_cell(ctx->net, ctx->cell); | |
601 | key_put(ctx->key); | |
602 | kfree(ctx); | |
603 | } | |
604 | ||
605 | static const struct fs_context_operations afs_context_ops = { | |
606 | .free = afs_free_fc, | |
607 | .parse_param = afs_parse_param, | |
608 | .get_tree = afs_get_tree, | |
609 | }; | |
610 | ||
611 | /* | |
612 | * Set up the filesystem mount context. | |
613 | */ | |
614 | static int afs_init_fs_context(struct fs_context *fc) | |
615 | { | |
616 | struct afs_fs_context *ctx; | |
617 | struct afs_cell *cell; | |
618 | ||
619 | if (current->nsproxy->net_ns != &init_net) | |
620 | return -EINVAL; | |
621 | ||
622 | ctx = kzalloc(sizeof(struct afs_fs_context), GFP_KERNEL); | |
623 | if (!ctx) | |
624 | return -ENOMEM; | |
625 | ||
626 | ctx->type = AFSVL_ROVOL; | |
627 | ctx->net = afs_net(fc->net_ns); | |
628 | ||
629 | /* Default to the workstation cell. */ | |
630 | rcu_read_lock(); | |
631 | cell = afs_lookup_cell_rcu(ctx->net, NULL, 0); | |
632 | rcu_read_unlock(); | |
633 | if (IS_ERR(cell)) | |
634 | cell = NULL; | |
635 | ctx->cell = cell; | |
636 | ||
637 | fc->fs_private = ctx; | |
638 | fc->ops = &afs_context_ops; | |
639 | return 0; | |
ec26815a | 640 | } |
1da177e4 | 641 | |
1da177e4 | 642 | /* |
f8de483e DH |
643 | * Initialise an inode cache slab element prior to any use. Note that |
644 | * afs_alloc_inode() *must* reset anything that could incorrectly leak from one | |
645 | * inode to another. | |
1da177e4 | 646 | */ |
51cc5068 | 647 | static void afs_i_init_once(void *_vnode) |
1da177e4 | 648 | { |
ec26815a | 649 | struct afs_vnode *vnode = _vnode; |
1da177e4 | 650 | |
a35afb83 CL |
651 | memset(vnode, 0, sizeof(*vnode)); |
652 | inode_init_once(&vnode->vfs_inode); | |
d2ddc776 | 653 | mutex_init(&vnode->io_lock); |
b61f7dcf | 654 | init_rwsem(&vnode->validate_lock); |
4343d008 | 655 | spin_lock_init(&vnode->wb_lock); |
a35afb83 | 656 | spin_lock_init(&vnode->lock); |
4343d008 | 657 | INIT_LIST_HEAD(&vnode->wb_keys); |
e8d6c554 DH |
658 | INIT_LIST_HEAD(&vnode->pending_locks); |
659 | INIT_LIST_HEAD(&vnode->granted_locks); | |
660 | INIT_DELAYED_WORK(&vnode->lock_work, afs_lock_work); | |
c435ee34 | 661 | seqlock_init(&vnode->cb_lock); |
ec26815a | 662 | } |
1da177e4 | 663 | |
1da177e4 LT |
664 | /* |
665 | * allocate an AFS inode struct from our slab cache | |
666 | */ | |
667 | static struct inode *afs_alloc_inode(struct super_block *sb) | |
668 | { | |
669 | struct afs_vnode *vnode; | |
670 | ||
ec26815a | 671 | vnode = kmem_cache_alloc(afs_inode_cachep, GFP_KERNEL); |
1da177e4 LT |
672 | if (!vnode) |
673 | return NULL; | |
674 | ||
675 | atomic_inc(&afs_count_active_inodes); | |
676 | ||
f8de483e | 677 | /* Reset anything that shouldn't leak from one inode to the next. */ |
1da177e4 LT |
678 | memset(&vnode->fid, 0, sizeof(vnode->fid)); |
679 | memset(&vnode->status, 0, sizeof(vnode->status)); | |
680 | ||
681 | vnode->volume = NULL; | |
f8de483e DH |
682 | vnode->lock_key = NULL; |
683 | vnode->permit_cache = NULL; | |
684 | vnode->cb_interest = NULL; | |
685 | #ifdef CONFIG_AFS_FSCACHE | |
686 | vnode->cache = NULL; | |
687 | #endif | |
688 | ||
260a9803 | 689 | vnode->flags = 1 << AFS_VNODE_UNSET; |
f8de483e DH |
690 | vnode->cb_type = 0; |
691 | vnode->lock_state = AFS_VNODE_LOCK_NONE; | |
1da177e4 | 692 | |
0f300ca9 | 693 | _leave(" = %p", &vnode->vfs_inode); |
1da177e4 | 694 | return &vnode->vfs_inode; |
ec26815a | 695 | } |
1da177e4 | 696 | |
fa0d7e3d NP |
697 | static void afs_i_callback(struct rcu_head *head) |
698 | { | |
699 | struct inode *inode = container_of(head, struct inode, i_rcu); | |
700 | struct afs_vnode *vnode = AFS_FS_I(inode); | |
fa0d7e3d NP |
701 | kmem_cache_free(afs_inode_cachep, vnode); |
702 | } | |
703 | ||
1da177e4 LT |
704 | /* |
705 | * destroy an AFS inode struct | |
706 | */ | |
707 | static void afs_destroy_inode(struct inode *inode) | |
708 | { | |
08e0e7c8 DH |
709 | struct afs_vnode *vnode = AFS_FS_I(inode); |
710 | ||
3b6492df | 711 | _enter("%p{%llx:%llu}", inode, vnode->fid.vid, vnode->fid.vnode); |
1da177e4 | 712 | |
08e0e7c8 DH |
713 | _debug("DESTROY INODE %p", inode); |
714 | ||
c435ee34 | 715 | ASSERTCMP(vnode->cb_interest, ==, NULL); |
08e0e7c8 | 716 | |
fa0d7e3d | 717 | call_rcu(&inode->i_rcu, afs_i_callback); |
1da177e4 | 718 | atomic_dec(&afs_count_active_inodes); |
ec26815a | 719 | } |
45222b9e DH |
720 | |
721 | /* | |
722 | * return information about an AFS volume | |
723 | */ | |
724 | static int afs_statfs(struct dentry *dentry, struct kstatfs *buf) | |
725 | { | |
4d673da1 | 726 | struct afs_super_info *as = AFS_FS_S(dentry->d_sb); |
d2ddc776 | 727 | struct afs_fs_cursor fc; |
45222b9e | 728 | struct afs_volume_status vs; |
2b0143b5 | 729 | struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry)); |
45222b9e DH |
730 | struct key *key; |
731 | int ret; | |
732 | ||
4d673da1 DH |
733 | buf->f_type = dentry->d_sb->s_magic; |
734 | buf->f_bsize = AFS_BLOCK_SIZE; | |
735 | buf->f_namelen = AFSNAMEMAX - 1; | |
736 | ||
737 | if (as->dyn_root) { | |
738 | buf->f_blocks = 1; | |
739 | buf->f_bavail = 0; | |
740 | buf->f_bfree = 0; | |
741 | return 0; | |
742 | } | |
66c7e1d3 | 743 | |
45222b9e DH |
744 | key = afs_request_key(vnode->volume->cell); |
745 | if (IS_ERR(key)) | |
746 | return PTR_ERR(key); | |
747 | ||
d2ddc776 DH |
748 | ret = -ERESTARTSYS; |
749 | if (afs_begin_vnode_operation(&fc, vnode, key)) { | |
750 | fc.flags |= AFS_FS_CURSOR_NO_VSLEEP; | |
751 | while (afs_select_fileserver(&fc)) { | |
68251f0a | 752 | fc.cb_break = afs_calc_vnode_cb_break(vnode); |
d2ddc776 DH |
753 | afs_fs_get_volume_status(&fc, &vs); |
754 | } | |
755 | ||
756 | afs_check_for_remote_deletion(&fc, fc.vnode); | |
757 | afs_vnode_commit_status(&fc, vnode, fc.cb_break); | |
758 | ret = afs_end_vnode_operation(&fc); | |
45222b9e DH |
759 | } |
760 | ||
d2ddc776 | 761 | key_put(key); |
45222b9e | 762 | |
d2ddc776 | 763 | if (ret == 0) { |
d2ddc776 DH |
764 | if (vs.max_quota == 0) |
765 | buf->f_blocks = vs.part_max_blocks; | |
766 | else | |
767 | buf->f_blocks = vs.max_quota; | |
768 | buf->f_bavail = buf->f_bfree = buf->f_blocks - vs.blocks_in_use; | |
769 | } | |
770 | ||
771 | return ret; | |
45222b9e | 772 | } |