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