diff options
author | Linus Torvalds <torvalds@woody.linux-foundation.org> | 2007-06-04 20:54:09 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@woody.linux-foundation.org> | 2007-06-04 20:54:09 -0400 |
commit | ec4883b015c3212f6f6d04fb2ff45f528492f598 (patch) | |
tree | 0e393eb198a35a90adafcd8129564d0173aafad4 /fs/jffs2/super.c | |
parent | 464cf177df7727efcc5506322fc5d0c8b896f545 (diff) | |
parent | 0477d24e2a87a9077b62298b01b031929f5cf2a2 (diff) |
Merge git://git.infradead.org/mtd-2.6
* git://git.infradead.org/mtd-2.6:
[JFFS2] Fix obsoletion of metadata nodes in jffs2_add_tn_to_tree()
[MTD] Fix error checking after get_mtd_device() in get_sb_mtd functions
[JFFS2] Fix buffer length calculations in jffs2_get_inode_nodes()
[JFFS2] Fix potential memory leak of dead xattrs on unmount.
[JFFS2] Fix BUG() caused by failing to discard xattrs on deleted files.
[MTD] generalise the handling of MTD-specific superblocks
[MTD] [MAPS] don't force uclinux mtd map to be root dev
Diffstat (limited to 'fs/jffs2/super.c')
-rw-r--r-- | fs/jffs2/super.c | 194 |
1 files changed, 19 insertions, 175 deletions
diff --git a/fs/jffs2/super.c b/fs/jffs2/super.c index 6488af43bc9b..e220d3bd610d 100644 --- a/fs/jffs2/super.c +++ b/fs/jffs2/super.c | |||
@@ -19,7 +19,7 @@ | |||
19 | #include <linux/mount.h> | 19 | #include <linux/mount.h> |
20 | #include <linux/jffs2.h> | 20 | #include <linux/jffs2.h> |
21 | #include <linux/pagemap.h> | 21 | #include <linux/pagemap.h> |
22 | #include <linux/mtd/mtd.h> | 22 | #include <linux/mtd/super.h> |
23 | #include <linux/ctype.h> | 23 | #include <linux/ctype.h> |
24 | #include <linux/namei.h> | 24 | #include <linux/namei.h> |
25 | #include "compr.h" | 25 | #include "compr.h" |
@@ -75,69 +75,27 @@ static const struct super_operations jffs2_super_operations = | |||
75 | .sync_fs = jffs2_sync_fs, | 75 | .sync_fs = jffs2_sync_fs, |
76 | }; | 76 | }; |
77 | 77 | ||
78 | static int jffs2_sb_compare(struct super_block *sb, void *data) | 78 | /* |
79 | { | 79 | * fill in the superblock |
80 | struct jffs2_sb_info *p = data; | 80 | */ |
81 | struct jffs2_sb_info *c = JFFS2_SB_INFO(sb); | 81 | static int jffs2_fill_super(struct super_block *sb, void *data, int silent) |
82 | |||
83 | /* The superblocks are considered to be equivalent if the underlying MTD | ||
84 | device is the same one */ | ||
85 | if (c->mtd == p->mtd) { | ||
86 | D1(printk(KERN_DEBUG "jffs2_sb_compare: match on device %d (\"%s\")\n", p->mtd->index, p->mtd->name)); | ||
87 | return 1; | ||
88 | } else { | ||
89 | D1(printk(KERN_DEBUG "jffs2_sb_compare: No match, device %d (\"%s\"), device %d (\"%s\")\n", | ||
90 | c->mtd->index, c->mtd->name, p->mtd->index, p->mtd->name)); | ||
91 | return 0; | ||
92 | } | ||
93 | } | ||
94 | |||
95 | static int jffs2_sb_set(struct super_block *sb, void *data) | ||
96 | { | ||
97 | struct jffs2_sb_info *p = data; | ||
98 | |||
99 | /* For persistence of NFS exports etc. we use the same s_dev | ||
100 | each time we mount the device, don't just use an anonymous | ||
101 | device */ | ||
102 | sb->s_fs_info = p; | ||
103 | p->os_priv = sb; | ||
104 | sb->s_dev = MKDEV(MTD_BLOCK_MAJOR, p->mtd->index); | ||
105 | |||
106 | return 0; | ||
107 | } | ||
108 | |||
109 | static int jffs2_get_sb_mtd(struct file_system_type *fs_type, | ||
110 | int flags, const char *dev_name, | ||
111 | void *data, struct mtd_info *mtd, | ||
112 | struct vfsmount *mnt) | ||
113 | { | 82 | { |
114 | struct super_block *sb; | ||
115 | struct jffs2_sb_info *c; | 83 | struct jffs2_sb_info *c; |
116 | int ret; | 84 | |
85 | D1(printk(KERN_DEBUG "jffs2_get_sb_mtd():" | ||
86 | " New superblock for device %d (\"%s\")\n", | ||
87 | sb->s_mtd->index, sb->s_mtd->name)); | ||
117 | 88 | ||
118 | c = kzalloc(sizeof(*c), GFP_KERNEL); | 89 | c = kzalloc(sizeof(*c), GFP_KERNEL); |
119 | if (!c) | 90 | if (!c) |
120 | return -ENOMEM; | 91 | return -ENOMEM; |
121 | c->mtd = mtd; | ||
122 | |||
123 | sb = sget(fs_type, jffs2_sb_compare, jffs2_sb_set, c); | ||
124 | |||
125 | if (IS_ERR(sb)) | ||
126 | goto out_error; | ||
127 | |||
128 | if (sb->s_root) { | ||
129 | /* New mountpoint for JFFS2 which is already mounted */ | ||
130 | D1(printk(KERN_DEBUG "jffs2_get_sb_mtd(): Device %d (\"%s\") is already mounted\n", | ||
131 | mtd->index, mtd->name)); | ||
132 | ret = simple_set_mnt(mnt, sb); | ||
133 | goto out_put; | ||
134 | } | ||
135 | 92 | ||
136 | D1(printk(KERN_DEBUG "jffs2_get_sb_mtd(): New superblock for device %d (\"%s\")\n", | 93 | c->mtd = sb->s_mtd; |
137 | mtd->index, mtd->name)); | 94 | c->os_priv = sb; |
95 | sb->s_fs_info = c; | ||
138 | 96 | ||
139 | /* Initialize JFFS2 superblock locks, the further initialization will be | 97 | /* Initialize JFFS2 superblock locks, the further initialization will |
140 | * done later */ | 98 | * be done later */ |
141 | init_MUTEX(&c->alloc_sem); | 99 | init_MUTEX(&c->alloc_sem); |
142 | init_MUTEX(&c->erase_free_sem); | 100 | init_MUTEX(&c->erase_free_sem); |
143 | init_waitqueue_head(&c->erase_wait); | 101 | init_waitqueue_head(&c->erase_wait); |
@@ -146,133 +104,20 @@ static int jffs2_get_sb_mtd(struct file_system_type *fs_type, | |||
146 | spin_lock_init(&c->inocache_lock); | 104 | spin_lock_init(&c->inocache_lock); |
147 | 105 | ||
148 | sb->s_op = &jffs2_super_operations; | 106 | sb->s_op = &jffs2_super_operations; |
149 | sb->s_flags = flags | MS_NOATIME; | 107 | sb->s_flags = sb->s_flags | MS_NOATIME; |
150 | sb->s_xattr = jffs2_xattr_handlers; | 108 | sb->s_xattr = jffs2_xattr_handlers; |
151 | #ifdef CONFIG_JFFS2_FS_POSIX_ACL | 109 | #ifdef CONFIG_JFFS2_FS_POSIX_ACL |
152 | sb->s_flags |= MS_POSIXACL; | 110 | sb->s_flags |= MS_POSIXACL; |
153 | #endif | 111 | #endif |
154 | ret = jffs2_do_fill_super(sb, data, flags & MS_SILENT ? 1 : 0); | 112 | return jffs2_do_fill_super(sb, data, silent); |
155 | |||
156 | if (ret) { | ||
157 | /* Failure case... */ | ||
158 | up_write(&sb->s_umount); | ||
159 | deactivate_super(sb); | ||
160 | return ret; | ||
161 | } | ||
162 | |||
163 | sb->s_flags |= MS_ACTIVE; | ||
164 | return simple_set_mnt(mnt, sb); | ||
165 | |||
166 | out_error: | ||
167 | ret = PTR_ERR(sb); | ||
168 | out_put: | ||
169 | kfree(c); | ||
170 | put_mtd_device(mtd); | ||
171 | |||
172 | return ret; | ||
173 | } | ||
174 | |||
175 | static int jffs2_get_sb_mtdnr(struct file_system_type *fs_type, | ||
176 | int flags, const char *dev_name, | ||
177 | void *data, int mtdnr, | ||
178 | struct vfsmount *mnt) | ||
179 | { | ||
180 | struct mtd_info *mtd; | ||
181 | |||
182 | mtd = get_mtd_device(NULL, mtdnr); | ||
183 | if (IS_ERR(mtd)) { | ||
184 | D1(printk(KERN_DEBUG "jffs2: MTD device #%u doesn't appear to exist\n", mtdnr)); | ||
185 | return PTR_ERR(mtd); | ||
186 | } | ||
187 | |||
188 | return jffs2_get_sb_mtd(fs_type, flags, dev_name, data, mtd, mnt); | ||
189 | } | 113 | } |
190 | 114 | ||
191 | static int jffs2_get_sb(struct file_system_type *fs_type, | 115 | static int jffs2_get_sb(struct file_system_type *fs_type, |
192 | int flags, const char *dev_name, | 116 | int flags, const char *dev_name, |
193 | void *data, struct vfsmount *mnt) | 117 | void *data, struct vfsmount *mnt) |
194 | { | 118 | { |
195 | int err; | 119 | return get_sb_mtd(fs_type, flags, dev_name, data, jffs2_fill_super, |
196 | struct nameidata nd; | 120 | mnt); |
197 | int mtdnr; | ||
198 | |||
199 | if (!dev_name) | ||
200 | return -EINVAL; | ||
201 | |||
202 | D1(printk(KERN_DEBUG "jffs2_get_sb(): dev_name \"%s\"\n", dev_name)); | ||
203 | |||
204 | /* The preferred way of mounting in future; especially when | ||
205 | CONFIG_BLK_DEV is implemented - we specify the underlying | ||
206 | MTD device by number or by name, so that we don't require | ||
207 | block device support to be present in the kernel. */ | ||
208 | |||
209 | /* FIXME: How to do the root fs this way? */ | ||
210 | |||
211 | if (dev_name[0] == 'm' && dev_name[1] == 't' && dev_name[2] == 'd') { | ||
212 | /* Probably mounting without the blkdev crap */ | ||
213 | if (dev_name[3] == ':') { | ||
214 | struct mtd_info *mtd; | ||
215 | |||
216 | /* Mount by MTD device name */ | ||
217 | D1(printk(KERN_DEBUG "jffs2_get_sb(): mtd:%%s, name \"%s\"\n", dev_name+4)); | ||
218 | for (mtdnr = 0; mtdnr < MAX_MTD_DEVICES; mtdnr++) { | ||
219 | mtd = get_mtd_device(NULL, mtdnr); | ||
220 | if (!IS_ERR(mtd)) { | ||
221 | if (!strcmp(mtd->name, dev_name+4)) | ||
222 | return jffs2_get_sb_mtd(fs_type, flags, dev_name, data, mtd, mnt); | ||
223 | put_mtd_device(mtd); | ||
224 | } | ||
225 | } | ||
226 | printk(KERN_NOTICE "jffs2_get_sb(): MTD device with name \"%s\" not found.\n", dev_name+4); | ||
227 | } else if (isdigit(dev_name[3])) { | ||
228 | /* Mount by MTD device number name */ | ||
229 | char *endptr; | ||
230 | |||
231 | mtdnr = simple_strtoul(dev_name+3, &endptr, 0); | ||
232 | if (!*endptr) { | ||
233 | /* It was a valid number */ | ||
234 | D1(printk(KERN_DEBUG "jffs2_get_sb(): mtd%%d, mtdnr %d\n", mtdnr)); | ||
235 | return jffs2_get_sb_mtdnr(fs_type, flags, dev_name, data, mtdnr, mnt); | ||
236 | } | ||
237 | } | ||
238 | } | ||
239 | |||
240 | /* Try the old way - the hack where we allowed users to mount | ||
241 | /dev/mtdblock$(n) but didn't actually _use_ the blkdev */ | ||
242 | |||
243 | err = path_lookup(dev_name, LOOKUP_FOLLOW, &nd); | ||
244 | |||
245 | D1(printk(KERN_DEBUG "jffs2_get_sb(): path_lookup() returned %d, inode %p\n", | ||
246 | err, nd.dentry->d_inode)); | ||
247 | |||
248 | if (err) | ||
249 | return err; | ||
250 | |||
251 | err = -EINVAL; | ||
252 | |||
253 | if (!S_ISBLK(nd.dentry->d_inode->i_mode)) | ||
254 | goto out; | ||
255 | |||
256 | if (nd.mnt->mnt_flags & MNT_NODEV) { | ||
257 | err = -EACCES; | ||
258 | goto out; | ||
259 | } | ||
260 | |||
261 | if (imajor(nd.dentry->d_inode) != MTD_BLOCK_MAJOR) { | ||
262 | if (!(flags & MS_SILENT)) | ||
263 | printk(KERN_NOTICE "Attempt to mount non-MTD device \"%s\" as JFFS2\n", | ||
264 | dev_name); | ||
265 | goto out; | ||
266 | } | ||
267 | |||
268 | mtdnr = iminor(nd.dentry->d_inode); | ||
269 | path_release(&nd); | ||
270 | |||
271 | return jffs2_get_sb_mtdnr(fs_type, flags, dev_name, data, mtdnr, mnt); | ||
272 | |||
273 | out: | ||
274 | path_release(&nd); | ||
275 | return err; | ||
276 | } | 121 | } |
277 | 122 | ||
278 | static void jffs2_put_super (struct super_block *sb) | 123 | static void jffs2_put_super (struct super_block *sb) |
@@ -307,8 +152,7 @@ static void jffs2_kill_sb(struct super_block *sb) | |||
307 | struct jffs2_sb_info *c = JFFS2_SB_INFO(sb); | 152 | struct jffs2_sb_info *c = JFFS2_SB_INFO(sb); |
308 | if (!(sb->s_flags & MS_RDONLY)) | 153 | if (!(sb->s_flags & MS_RDONLY)) |
309 | jffs2_stop_garbage_collect_thread(c); | 154 | jffs2_stop_garbage_collect_thread(c); |
310 | generic_shutdown_super(sb); | 155 | kill_mtd_super(sb); |
311 | put_mtd_device(c->mtd); | ||
312 | kfree(c); | 156 | kfree(c); |
313 | } | 157 | } |
314 | 158 | ||