Commit | Line | Data |
---|---|---|
2874c5fd | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
acaebfd8 DH |
2 | /* MTD-based superblock management |
3 | * | |
4 | * Copyright © 2001-2007 Red Hat, Inc. All Rights Reserved. | |
a1452a37 DW |
5 | * Copyright © 2001-2010 David Woodhouse <dwmw2@infradead.org> |
6 | * | |
acaebfd8 DH |
7 | * Written by: David Howells <dhowells@redhat.com> |
8 | * David Woodhouse <dwmw2@infradead.org> | |
acaebfd8 DH |
9 | */ |
10 | ||
11 | #include <linux/mtd/super.h> | |
12 | #include <linux/namei.h> | |
f3bcc017 | 13 | #include <linux/export.h> |
acaebfd8 | 14 | #include <linux/ctype.h> |
6de94002 | 15 | #include <linux/slab.h> |
f83c3838 | 16 | #include <linux/major.h> |
fa06052d | 17 | #include <linux/backing-dev.h> |
ccdf7741 | 18 | #include <linux/blkdev.h> |
0f071004 DH |
19 | #include <linux/fs_context.h> |
20 | #include "mtdcore.h" | |
21 | ||
0f071004 DH |
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 | ||
ec952aa2 | 33 | sb = sget_dev(fc, MKDEV(MTD_BLOCK_MAJOR, mtd->index)); |
0f071004 DH |
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 | ||
ec952aa2 CB |
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 | ||
0f071004 DH |
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 | |
4e7b5671 CH |
101 | dev_t dev; |
102 | int ret; | |
0f071004 DH |
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 | */ | |
4e7b5671 CH |
150 | ret = lookup_bdev(fc->source, &dev); |
151 | if (ret) { | |
0f071004 DH |
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 | ||
4e7b5671 CH |
157 | if (MAJOR(dev) == MTD_BLOCK_MAJOR) |
158 | return mtd_get_sb_by_nr(fc, MINOR(dev), fill_super); | |
0f071004 DH |
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); | |
acaebfd8 | 168 | |
acaebfd8 DH |
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); |