drivers/mtd/mtdsuper.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* MTD-based superblock management
   3  *
   4  * Copyright © 2001-2007 Red Hat, Inc. All Rights Reserved.
   5  * Copyright © 2001-2010 David Woodhouse <dwmw2@infradead.org>
   6  *
   7  * Written by:  David Howells <dhowells@redhat.com>
   8  *              David Woodhouse <dwmw2@infradead.org>
   9  */
  10
  11 #include <linux/mtd/super.h>
  12 #include <linux/namei.h>
  13 #include <linux/export.h>
  14 #include <linux/ctype.h>
  15 #include <linux/slab.h>
  16 #include <linux/major.h>
  17 #include <linux/backing-dev.h>
  18 #include <linux/blkdev.h>
  19 #include <linux/fs_context.h>
  20 #include "mtdcore.h"
  21
  22 /*
  23  * get a superblock on an MTD-backed filesystem
  24  */
  25 static int mtd_get_sb(struct fs_context *fc,
  26                       struct mtd_info *mtd,
  27                       int (*fill_super)(struct super_block *,
  28                                         struct fs_context *))
  29 {
  30         struct super_block *sb;
  31         int ret;
  32
  33         sb = sget_dev(fc, MKDEV(MTD_BLOCK_MAJOR, mtd->index));
  34         if (IS_ERR(sb))
  35                 return PTR_ERR(sb);
  36
  37         if (sb->s_root) {
  38                 /* new mountpoint for an already mounted superblock */
  39                 pr_debug("MTDSB: Device %d (\"%s\") is already mounted\n",
  40                          mtd->index, mtd->name);
  41                 put_mtd_device(mtd);
  42         } else {
  43                 /* fresh new superblock */
  44                 pr_debug("MTDSB: New superblock for device %d (\"%s\")\n",
  45                          mtd->index, mtd->name);
  46
  47                 /*
  48                  * Would usually have been set with @sb_lock held but in
  49                  * contrast to sb->s_bdev that's checked with only
  50                  * @sb_lock held, nothing checks sb->s_mtd without also
  51                  * holding sb->s_umount and we're holding sb->s_umount
  52                  * here.
  53                  */
  54                 sb->s_mtd = mtd;
  55                 sb->s_bdi = bdi_get(mtd_bdi);
  56
  57                 ret = fill_super(sb, fc);
  58                 if (ret < 0)
  59                         goto error_sb;
  60
  61                 sb->s_flags |= SB_ACTIVE;
  62         }
  63
  64         BUG_ON(fc->root);
  65         fc->root = dget(sb->s_root);
  66         return 0;
  67
  68 error_sb:
  69         deactivate_locked_super(sb);
  70         return ret;
  71 }
  72
  73 /*
  74  * get a superblock on an MTD-backed filesystem by MTD device number
  75  */
  76 static int mtd_get_sb_by_nr(struct fs_context *fc, int mtdnr,
  77                             int (*fill_super)(struct super_block *,
  78                                               struct fs_context *))
  79 {
  80         struct mtd_info *mtd;
  81
  82         mtd = get_mtd_device(NULL, mtdnr);
  83         if (IS_ERR(mtd)) {
  84                 errorf(fc, "MTDSB: Device #%u doesn't appear to exist\n", mtdnr);
  85                 return PTR_ERR(mtd);
  86         }
  87
  88         return mtd_get_sb(fc, mtd, fill_super);
  89 }
  90
  91 /**
  92  * get_tree_mtd - Get a superblock based on a single MTD device
  93  * @fc: The filesystem context holding the parameters
  94  * @fill_super: Helper to initialise a new superblock
  95  */
  96 int get_tree_mtd(struct fs_context *fc,
  97               int (*fill_super)(struct super_block *sb,
  98                                 struct fs_context *fc))
  99 {
 100 #ifdef CONFIG_BLOCK
 101         dev_t dev;
 102         int ret;
 103 #endif
 104         int mtdnr;
 105
 106         if (!fc->source)
 107                 return invalf(fc, "No source specified");
 108
 109         pr_debug("MTDSB: dev_name \"%s\"\n", fc->source);
 110
 111         /* the preferred way of mounting in future; especially when
 112          * CONFIG_BLOCK=n - we specify the underlying MTD device by number or
 113          * by name, so that we don't require block device support to be present
 114          * in the kernel.
 115          */
 116         if (fc->source[0] == 'm' &&
 117             fc->source[1] == 't' &&
 118             fc->source[2] == 'd') {
 119                 if (fc->source[3] == ':') {
 120                         struct mtd_info *mtd;
 121
 122                         /* mount by MTD device name */
 123                         pr_debug("MTDSB: mtd:%%s, name \"%s\"\n",
 124                                  fc->source + 4);
 125
 126                         mtd = get_mtd_device_nm(fc->source + 4);
 127                         if (!IS_ERR(mtd))
 128                                 return mtd_get_sb(fc, mtd, fill_super);
 129
 130                         errorf(fc, "MTD: MTD device with name \"%s\" not found",
 131                                fc->source + 4);
 132
 133                 } else if (isdigit(fc->source[3])) {
 134                         /* mount by MTD device number name */
 135                         char *endptr;
 136
 137                         mtdnr = simple_strtoul(fc->source + 3, &endptr, 0);
 138                         if (!*endptr) {
 139                                 /* It was a valid number */
 140                                 pr_debug("MTDSB: mtd%%d, mtdnr %d\n", mtdnr);
 141                                 return mtd_get_sb_by_nr(fc, mtdnr, fill_super);
 142                         }
 143                 }
 144         }
 145
 146 #ifdef CONFIG_BLOCK
 147         /* try the old way - the hack where we allowed users to mount
 148          * /dev/mtdblock$(n) but didn't actually _use_ the blockdev
 149          */
 150         ret = lookup_bdev(fc->source, &dev);
 151         if (ret) {
 152                 errorf(fc, "MTD: Couldn't look up '%s': %d", fc->source, ret);
 153                 return ret;
 154         }
 155         pr_debug("MTDSB: lookup_bdev() returned 0\n");
 156
 157         if (MAJOR(dev) == MTD_BLOCK_MAJOR)
 158                 return mtd_get_sb_by_nr(fc, MINOR(dev), fill_super);
 159
 160 #endif /* CONFIG_BLOCK */
 161
 162         if (!(fc->sb_flags & SB_SILENT))
 163                 errorf(fc, "MTD: Attempt to mount non-MTD device \"%s\"",
 164                        fc->source);
 165         return -EINVAL;
 166 }
 167 EXPORT_SYMBOL_GPL(get_tree_mtd);
 168
 169 /*
 170  * destroy an MTD-based superblock
 171  */
 172 void kill_mtd_super(struct super_block *sb)
 173 {
 174         generic_shutdown_super(sb);
 175         put_mtd_device(sb->s_mtd);
 176         sb->s_mtd = NULL;
 177 }
 178
 179 EXPORT_SYMBOL_GPL(kill_mtd_super);