~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/afs/super.c

Version: ~ [ linux-5.15-rc1 ] ~ [ linux-5.14.5 ] ~ [ linux-5.13.18 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.66 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.147 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.206 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.246 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.282 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.283 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp