Commit | Line | Data |
---|---|---|
acaebfd8 DH |
1 | /* MTD-based superblock management |
2 | * | |
3 | * Copyright © 2001-2007 Red Hat, Inc. All Rights Reserved. | |
a1452a37 DW |
4 | * Copyright © 2001-2010 David Woodhouse <dwmw2@infradead.org> |
5 | * | |
acaebfd8 DH |
6 | * Written by: David Howells <dhowells@redhat.com> |
7 | * David Woodhouse <dwmw2@infradead.org> | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or | |
10 | * modify it under the terms of the GNU General Public License | |
11 | * as published by the Free Software Foundation; either version | |
12 | * 2 of the License, or (at your option) any later version. | |
13 | */ | |
14 | ||
15 | #include <linux/mtd/super.h> | |
16 | #include <linux/namei.h> | |
f3bcc017 | 17 | #include <linux/export.h> |
acaebfd8 | 18 | #include <linux/ctype.h> |
6de94002 | 19 | #include <linux/slab.h> |
acaebfd8 DH |
20 | |
21 | /* | |
22 | * compare superblocks to see if they're equivalent | |
23 | * - they are if the underlying MTD device is the same | |
24 | */ | |
25 | static int get_sb_mtd_compare(struct super_block *sb, void *_mtd) | |
26 | { | |
27 | struct mtd_info *mtd = _mtd; | |
28 | ||
29 | if (sb->s_mtd == mtd) { | |
289c0522 | 30 | pr_debug("MTDSB: Match on device %d (\"%s\")\n", |
acaebfd8 DH |
31 | mtd->index, mtd->name); |
32 | return 1; | |
33 | } | |
34 | ||
289c0522 | 35 | pr_debug("MTDSB: No match, device %d (\"%s\"), device %d (\"%s\")\n", |
acaebfd8 DH |
36 | sb->s_mtd->index, sb->s_mtd->name, mtd->index, mtd->name); |
37 | return 0; | |
38 | } | |
39 | ||
40 | /* | |
41 | * mark the superblock by the MTD device it is using | |
42 | * - set the device number to be the correct MTD block device for pesuperstence | |
43 | * of NFS exports | |
44 | */ | |
45 | static int get_sb_mtd_set(struct super_block *sb, void *_mtd) | |
46 | { | |
47 | struct mtd_info *mtd = _mtd; | |
48 | ||
49 | sb->s_mtd = mtd; | |
50 | sb->s_dev = MKDEV(MTD_BLOCK_MAJOR, mtd->index); | |
6de94002 | 51 | sb->s_bdi = mtd->backing_dev_info; |
acaebfd8 DH |
52 | return 0; |
53 | } | |
54 | ||
55 | /* | |
56 | * get a superblock on an MTD-backed filesystem | |
57 | */ | |
848b83a5 | 58 | static struct dentry *mount_mtd_aux(struct file_system_type *fs_type, int flags, |
acaebfd8 DH |
59 | const char *dev_name, void *data, |
60 | struct mtd_info *mtd, | |
848b83a5 | 61 | int (*fill_super)(struct super_block *, void *, int)) |
acaebfd8 DH |
62 | { |
63 | struct super_block *sb; | |
64 | int ret; | |
65 | ||
66 | sb = sget(fs_type, get_sb_mtd_compare, get_sb_mtd_set, mtd); | |
67 | if (IS_ERR(sb)) | |
68 | goto out_error; | |
69 | ||
70 | if (sb->s_root) | |
71 | goto already_mounted; | |
72 | ||
73 | /* fresh new superblock */ | |
289c0522 | 74 | pr_debug("MTDSB: New superblock for device %d (\"%s\")\n", |
acaebfd8 DH |
75 | mtd->index, mtd->name); |
76 | ||
48440e89 DH |
77 | sb->s_flags = flags; |
78 | ||
acaebfd8 DH |
79 | ret = fill_super(sb, data, flags & MS_SILENT ? 1 : 0); |
80 | if (ret < 0) { | |
6f5bbff9 | 81 | deactivate_locked_super(sb); |
848b83a5 | 82 | return ERR_PTR(ret); |
acaebfd8 DH |
83 | } |
84 | ||
85 | /* go */ | |
86 | sb->s_flags |= MS_ACTIVE; | |
848b83a5 | 87 | return dget(sb->s_root); |
acaebfd8 DH |
88 | |
89 | /* new mountpoint for an already mounted superblock */ | |
90 | already_mounted: | |
289c0522 | 91 | pr_debug("MTDSB: Device %d (\"%s\") is already mounted\n", |
acaebfd8 | 92 | mtd->index, mtd->name); |
848b83a5 AV |
93 | put_mtd_device(mtd); |
94 | return dget(sb->s_root); | |
acaebfd8 DH |
95 | |
96 | out_error: | |
acaebfd8 | 97 | put_mtd_device(mtd); |
848b83a5 | 98 | return ERR_CAST(sb); |
acaebfd8 DH |
99 | } |
100 | ||
101 | /* | |
102 | * get a superblock on an MTD-backed filesystem by MTD device number | |
103 | */ | |
848b83a5 | 104 | static struct dentry *mount_mtd_nr(struct file_system_type *fs_type, int flags, |
acaebfd8 | 105 | const char *dev_name, void *data, int mtdnr, |
848b83a5 | 106 | int (*fill_super)(struct super_block *, void *, int)) |
acaebfd8 DH |
107 | { |
108 | struct mtd_info *mtd; | |
109 | ||
110 | mtd = get_mtd_device(NULL, mtdnr); | |
718ea836 | 111 | if (IS_ERR(mtd)) { |
289c0522 | 112 | pr_debug("MTDSB: Device #%u doesn't appear to exist\n", mtdnr); |
848b83a5 | 113 | return ERR_CAST(mtd); |
acaebfd8 DH |
114 | } |
115 | ||
848b83a5 | 116 | return mount_mtd_aux(fs_type, flags, dev_name, data, mtd, fill_super); |
acaebfd8 DH |
117 | } |
118 | ||
119 | /* | |
120 | * set up an MTD-based superblock | |
121 | */ | |
848b83a5 | 122 | struct dentry *mount_mtd(struct file_system_type *fs_type, int flags, |
acaebfd8 | 123 | const char *dev_name, void *data, |
848b83a5 | 124 | int (*fill_super)(struct super_block *, void *, int)) |
acaebfd8 | 125 | { |
f1136d02 | 126 | #ifdef CONFIG_BLOCK |
d5686b44 | 127 | struct block_device *bdev; |
f1136d02 DW |
128 | int ret, major; |
129 | #endif | |
130 | int mtdnr; | |
acaebfd8 DH |
131 | |
132 | if (!dev_name) | |
848b83a5 | 133 | return ERR_PTR(-EINVAL); |
acaebfd8 | 134 | |
289c0522 | 135 | pr_debug("MTDSB: dev_name \"%s\"\n", dev_name); |
acaebfd8 DH |
136 | |
137 | /* the preferred way of mounting in future; especially when | |
138 | * CONFIG_BLOCK=n - we specify the underlying MTD device by number or | |
139 | * by name, so that we don't require block device support to be present | |
140 | * in the kernel. */ | |
141 | if (dev_name[0] == 'm' && dev_name[1] == 't' && dev_name[2] == 'd') { | |
142 | if (dev_name[3] == ':') { | |
143 | struct mtd_info *mtd; | |
144 | ||
145 | /* mount by MTD device name */ | |
289c0522 | 146 | pr_debug("MTDSB: mtd:%%s, name \"%s\"\n", |
acaebfd8 DH |
147 | dev_name + 4); |
148 | ||
677c2aec BH |
149 | mtd = get_mtd_device_nm(dev_name + 4); |
150 | if (!IS_ERR(mtd)) | |
848b83a5 | 151 | return mount_mtd_aux( |
677c2aec BH |
152 | fs_type, flags, |
153 | dev_name, data, mtd, | |
848b83a5 | 154 | fill_super); |
acaebfd8 DH |
155 | |
156 | printk(KERN_NOTICE "MTD:" | |
157 | " MTD device with name \"%s\" not found.\n", | |
158 | dev_name + 4); | |
159 | ||
160 | } else if (isdigit(dev_name[3])) { | |
161 | /* mount by MTD device number name */ | |
162 | char *endptr; | |
163 | ||
164 | mtdnr = simple_strtoul(dev_name + 3, &endptr, 0); | |
165 | if (!*endptr) { | |
166 | /* It was a valid number */ | |
289c0522 | 167 | pr_debug("MTDSB: mtd%%d, mtdnr %d\n", |
acaebfd8 | 168 | mtdnr); |
848b83a5 | 169 | return mount_mtd_nr(fs_type, flags, |
acaebfd8 | 170 | dev_name, data, |
848b83a5 | 171 | mtdnr, fill_super); |
acaebfd8 DH |
172 | } |
173 | } | |
174 | } | |
175 | ||
f1136d02 | 176 | #ifdef CONFIG_BLOCK |
acaebfd8 DH |
177 | /* try the old way - the hack where we allowed users to mount |
178 | * /dev/mtdblock$(n) but didn't actually _use_ the blockdev | |
179 | */ | |
d5686b44 AV |
180 | bdev = lookup_bdev(dev_name); |
181 | if (IS_ERR(bdev)) { | |
182 | ret = PTR_ERR(bdev); | |
289c0522 | 183 | pr_debug("MTDSB: lookup_bdev() returned %d\n", ret); |
848b83a5 | 184 | return ERR_PTR(ret); |
acaebfd8 | 185 | } |
289c0522 | 186 | pr_debug("MTDSB: lookup_bdev() returned 0\n"); |
acaebfd8 | 187 | |
d5686b44 | 188 | ret = -EINVAL; |
acaebfd8 | 189 | |
f1136d02 | 190 | major = MAJOR(bdev->bd_dev); |
d5686b44 AV |
191 | mtdnr = MINOR(bdev->bd_dev); |
192 | bdput(bdev); | |
acaebfd8 | 193 | |
f1136d02 DW |
194 | if (major != MTD_BLOCK_MAJOR) |
195 | goto not_an_MTD_device; | |
196 | ||
848b83a5 | 197 | return mount_mtd_nr(fs_type, flags, dev_name, data, mtdnr, fill_super); |
acaebfd8 DH |
198 | |
199 | not_an_MTD_device: | |
f1136d02 DW |
200 | #endif /* CONFIG_BLOCK */ |
201 | ||
acaebfd8 DH |
202 | if (!(flags & MS_SILENT)) |
203 | printk(KERN_NOTICE | |
204 | "MTD: Attempt to mount non-MTD device \"%s\"\n", | |
205 | dev_name); | |
848b83a5 | 206 | return ERR_PTR(-EINVAL); |
acaebfd8 DH |
207 | } |
208 | ||
848b83a5 | 209 | EXPORT_SYMBOL_GPL(mount_mtd); |
acaebfd8 DH |
210 | |
211 | /* | |
212 | * destroy an MTD-based superblock | |
213 | */ | |
214 | void kill_mtd_super(struct super_block *sb) | |
215 | { | |
216 | generic_shutdown_super(sb); | |
217 | put_mtd_device(sb->s_mtd); | |
218 | sb->s_mtd = NULL; | |
219 | } | |
220 | ||
221 | EXPORT_SYMBOL_GPL(kill_mtd_super); |