diff options
Diffstat (limited to 'fs/ubifs/super.c')
-rw-r--r-- | fs/ubifs/super.c | 1951 |
1 files changed, 1951 insertions, 0 deletions
diff --git a/fs/ubifs/super.c b/fs/ubifs/super.c new file mode 100644 index 000000000000..00eb9c68ad03 --- /dev/null +++ b/fs/ubifs/super.c | |||
@@ -0,0 +1,1951 @@ | |||
1 | /* | ||
2 | * This file is part of UBIFS. | ||
3 | * | ||
4 | * Copyright (C) 2006-2008 Nokia Corporation. | ||
5 | * | ||
6 | * This program is free software; you can redistribute it and/or modify it | ||
7 | * under the terms of the GNU General Public License version 2 as published by | ||
8 | * the Free Software Foundation. | ||
9 | * | ||
10 | * This program is distributed in the hope that it will be useful, but WITHOUT | ||
11 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
12 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | ||
13 | * more details. | ||
14 | * | ||
15 | * You should have received a copy of the GNU General Public License along with | ||
16 | * this program; if not, write to the Free Software Foundation, Inc., 51 | ||
17 | * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | * | ||
19 | * Authors: Artem Bityutskiy (Битюцкий Артём) | ||
20 | * Adrian Hunter | ||
21 | */ | ||
22 | |||
23 | /* | ||
24 | * This file implements UBIFS initialization and VFS superblock operations. Some | ||
25 | * initialization stuff which is rather large and complex is placed at | ||
26 | * corresponding subsystems, but most of it is here. | ||
27 | */ | ||
28 | |||
29 | #include <linux/init.h> | ||
30 | #include <linux/slab.h> | ||
31 | #include <linux/module.h> | ||
32 | #include <linux/ctype.h> | ||
33 | #include <linux/random.h> | ||
34 | #include <linux/kthread.h> | ||
35 | #include <linux/parser.h> | ||
36 | #include <linux/seq_file.h> | ||
37 | #include <linux/mount.h> | ||
38 | #include "ubifs.h" | ||
39 | |||
40 | /* Slab cache for UBIFS inodes */ | ||
41 | struct kmem_cache *ubifs_inode_slab; | ||
42 | |||
43 | /* UBIFS TNC shrinker description */ | ||
44 | static struct shrinker ubifs_shrinker_info = { | ||
45 | .shrink = ubifs_shrinker, | ||
46 | .seeks = DEFAULT_SEEKS, | ||
47 | }; | ||
48 | |||
49 | /** | ||
50 | * validate_inode - validate inode. | ||
51 | * @c: UBIFS file-system description object | ||
52 | * @inode: the inode to validate | ||
53 | * | ||
54 | * This is a helper function for 'ubifs_iget()' which validates various fields | ||
55 | * of a newly built inode to make sure they contain sane values and prevent | ||
56 | * possible vulnerabilities. Returns zero if the inode is all right and | ||
57 | * a non-zero error code if not. | ||
58 | */ | ||
59 | static int validate_inode(struct ubifs_info *c, const struct inode *inode) | ||
60 | { | ||
61 | int err; | ||
62 | const struct ubifs_inode *ui = ubifs_inode(inode); | ||
63 | |||
64 | if (inode->i_size > c->max_inode_sz) { | ||
65 | ubifs_err("inode is too large (%lld)", | ||
66 | (long long)inode->i_size); | ||
67 | return 1; | ||
68 | } | ||
69 | |||
70 | if (ui->compr_type < 0 || ui->compr_type >= UBIFS_COMPR_TYPES_CNT) { | ||
71 | ubifs_err("unknown compression type %d", ui->compr_type); | ||
72 | return 2; | ||
73 | } | ||
74 | |||
75 | if (ui->xattr_names + ui->xattr_cnt > XATTR_LIST_MAX) | ||
76 | return 3; | ||
77 | |||
78 | if (ui->data_len < 0 || ui->data_len > UBIFS_MAX_INO_DATA) | ||
79 | return 4; | ||
80 | |||
81 | if (ui->xattr && (inode->i_mode & S_IFMT) != S_IFREG) | ||
82 | return 5; | ||
83 | |||
84 | if (!ubifs_compr_present(ui->compr_type)) { | ||
85 | ubifs_warn("inode %lu uses '%s' compression, but it was not " | ||
86 | "compiled in", inode->i_ino, | ||
87 | ubifs_compr_name(ui->compr_type)); | ||
88 | } | ||
89 | |||
90 | err = dbg_check_dir_size(c, inode); | ||
91 | return err; | ||
92 | } | ||
93 | |||
94 | struct inode *ubifs_iget(struct super_block *sb, unsigned long inum) | ||
95 | { | ||
96 | int err; | ||
97 | union ubifs_key key; | ||
98 | struct ubifs_ino_node *ino; | ||
99 | struct ubifs_info *c = sb->s_fs_info; | ||
100 | struct inode *inode; | ||
101 | struct ubifs_inode *ui; | ||
102 | |||
103 | dbg_gen("inode %lu", inum); | ||
104 | |||
105 | inode = iget_locked(sb, inum); | ||
106 | if (!inode) | ||
107 | return ERR_PTR(-ENOMEM); | ||
108 | if (!(inode->i_state & I_NEW)) | ||
109 | return inode; | ||
110 | ui = ubifs_inode(inode); | ||
111 | |||
112 | ino = kmalloc(UBIFS_MAX_INO_NODE_SZ, GFP_NOFS); | ||
113 | if (!ino) { | ||
114 | err = -ENOMEM; | ||
115 | goto out; | ||
116 | } | ||
117 | |||
118 | ino_key_init(c, &key, inode->i_ino); | ||
119 | |||
120 | err = ubifs_tnc_lookup(c, &key, ino); | ||
121 | if (err) | ||
122 | goto out_ino; | ||
123 | |||
124 | inode->i_flags |= (S_NOCMTIME | S_NOATIME); | ||
125 | inode->i_nlink = le32_to_cpu(ino->nlink); | ||
126 | inode->i_uid = le32_to_cpu(ino->uid); | ||
127 | inode->i_gid = le32_to_cpu(ino->gid); | ||
128 | inode->i_atime.tv_sec = (int64_t)le64_to_cpu(ino->atime_sec); | ||
129 | inode->i_atime.tv_nsec = le32_to_cpu(ino->atime_nsec); | ||
130 | inode->i_mtime.tv_sec = (int64_t)le64_to_cpu(ino->mtime_sec); | ||
131 | inode->i_mtime.tv_nsec = le32_to_cpu(ino->mtime_nsec); | ||
132 | inode->i_ctime.tv_sec = (int64_t)le64_to_cpu(ino->ctime_sec); | ||
133 | inode->i_ctime.tv_nsec = le32_to_cpu(ino->ctime_nsec); | ||
134 | inode->i_mode = le32_to_cpu(ino->mode); | ||
135 | inode->i_size = le64_to_cpu(ino->size); | ||
136 | |||
137 | ui->data_len = le32_to_cpu(ino->data_len); | ||
138 | ui->flags = le32_to_cpu(ino->flags); | ||
139 | ui->compr_type = le16_to_cpu(ino->compr_type); | ||
140 | ui->creat_sqnum = le64_to_cpu(ino->creat_sqnum); | ||
141 | ui->xattr_cnt = le32_to_cpu(ino->xattr_cnt); | ||
142 | ui->xattr_size = le32_to_cpu(ino->xattr_size); | ||
143 | ui->xattr_names = le32_to_cpu(ino->xattr_names); | ||
144 | ui->synced_i_size = ui->ui_size = inode->i_size; | ||
145 | |||
146 | ui->xattr = (ui->flags & UBIFS_XATTR_FL) ? 1 : 0; | ||
147 | |||
148 | err = validate_inode(c, inode); | ||
149 | if (err) | ||
150 | goto out_invalid; | ||
151 | |||
152 | /* Disable readahead */ | ||
153 | inode->i_mapping->backing_dev_info = &c->bdi; | ||
154 | |||
155 | switch (inode->i_mode & S_IFMT) { | ||
156 | case S_IFREG: | ||
157 | inode->i_mapping->a_ops = &ubifs_file_address_operations; | ||
158 | inode->i_op = &ubifs_file_inode_operations; | ||
159 | inode->i_fop = &ubifs_file_operations; | ||
160 | if (ui->xattr) { | ||
161 | ui->data = kmalloc(ui->data_len + 1, GFP_NOFS); | ||
162 | if (!ui->data) { | ||
163 | err = -ENOMEM; | ||
164 | goto out_ino; | ||
165 | } | ||
166 | memcpy(ui->data, ino->data, ui->data_len); | ||
167 | ((char *)ui->data)[ui->data_len] = '\0'; | ||
168 | } else if (ui->data_len != 0) { | ||
169 | err = 10; | ||
170 | goto out_invalid; | ||
171 | } | ||
172 | break; | ||
173 | case S_IFDIR: | ||
174 | inode->i_op = &ubifs_dir_inode_operations; | ||
175 | inode->i_fop = &ubifs_dir_operations; | ||
176 | if (ui->data_len != 0) { | ||
177 | err = 11; | ||
178 | goto out_invalid; | ||
179 | } | ||
180 | break; | ||
181 | case S_IFLNK: | ||
182 | inode->i_op = &ubifs_symlink_inode_operations; | ||
183 | if (ui->data_len <= 0 || ui->data_len > UBIFS_MAX_INO_DATA) { | ||
184 | err = 12; | ||
185 | goto out_invalid; | ||
186 | } | ||
187 | ui->data = kmalloc(ui->data_len + 1, GFP_NOFS); | ||
188 | if (!ui->data) { | ||
189 | err = -ENOMEM; | ||
190 | goto out_ino; | ||
191 | } | ||
192 | memcpy(ui->data, ino->data, ui->data_len); | ||
193 | ((char *)ui->data)[ui->data_len] = '\0'; | ||
194 | break; | ||
195 | case S_IFBLK: | ||
196 | case S_IFCHR: | ||
197 | { | ||
198 | dev_t rdev; | ||
199 | union ubifs_dev_desc *dev; | ||
200 | |||
201 | ui->data = kmalloc(sizeof(union ubifs_dev_desc), GFP_NOFS); | ||
202 | if (!ui->data) { | ||
203 | err = -ENOMEM; | ||
204 | goto out_ino; | ||
205 | } | ||
206 | |||
207 | dev = (union ubifs_dev_desc *)ino->data; | ||
208 | if (ui->data_len == sizeof(dev->new)) | ||
209 | rdev = new_decode_dev(le32_to_cpu(dev->new)); | ||
210 | else if (ui->data_len == sizeof(dev->huge)) | ||
211 | rdev = huge_decode_dev(le64_to_cpu(dev->huge)); | ||
212 | else { | ||
213 | err = 13; | ||
214 | goto out_invalid; | ||
215 | } | ||
216 | memcpy(ui->data, ino->data, ui->data_len); | ||
217 | inode->i_op = &ubifs_file_inode_operations; | ||
218 | init_special_inode(inode, inode->i_mode, rdev); | ||
219 | break; | ||
220 | } | ||
221 | case S_IFSOCK: | ||
222 | case S_IFIFO: | ||
223 | inode->i_op = &ubifs_file_inode_operations; | ||
224 | init_special_inode(inode, inode->i_mode, 0); | ||
225 | if (ui->data_len != 0) { | ||
226 | err = 14; | ||
227 | goto out_invalid; | ||
228 | } | ||
229 | break; | ||
230 | default: | ||
231 | err = 15; | ||
232 | goto out_invalid; | ||
233 | } | ||
234 | |||
235 | kfree(ino); | ||
236 | ubifs_set_inode_flags(inode); | ||
237 | unlock_new_inode(inode); | ||
238 | return inode; | ||
239 | |||
240 | out_invalid: | ||
241 | ubifs_err("inode %lu validation failed, error %d", inode->i_ino, err); | ||
242 | dbg_dump_node(c, ino); | ||
243 | dbg_dump_inode(c, inode); | ||
244 | err = -EINVAL; | ||
245 | out_ino: | ||
246 | kfree(ino); | ||
247 | out: | ||
248 | ubifs_err("failed to read inode %lu, error %d", inode->i_ino, err); | ||
249 | iget_failed(inode); | ||
250 | return ERR_PTR(err); | ||
251 | } | ||
252 | |||
253 | static struct inode *ubifs_alloc_inode(struct super_block *sb) | ||
254 | { | ||
255 | struct ubifs_inode *ui; | ||
256 | |||
257 | ui = kmem_cache_alloc(ubifs_inode_slab, GFP_NOFS); | ||
258 | if (!ui) | ||
259 | return NULL; | ||
260 | |||
261 | memset((void *)ui + sizeof(struct inode), 0, | ||
262 | sizeof(struct ubifs_inode) - sizeof(struct inode)); | ||
263 | mutex_init(&ui->ui_mutex); | ||
264 | spin_lock_init(&ui->ui_lock); | ||
265 | return &ui->vfs_inode; | ||
266 | }; | ||
267 | |||
268 | static void ubifs_destroy_inode(struct inode *inode) | ||
269 | { | ||
270 | struct ubifs_inode *ui = ubifs_inode(inode); | ||
271 | |||
272 | kfree(ui->data); | ||
273 | kmem_cache_free(ubifs_inode_slab, inode); | ||
274 | } | ||
275 | |||
276 | /* | ||
277 | * Note, Linux write-back code calls this without 'i_mutex'. | ||
278 | */ | ||
279 | static int ubifs_write_inode(struct inode *inode, int wait) | ||
280 | { | ||
281 | int err; | ||
282 | struct ubifs_info *c = inode->i_sb->s_fs_info; | ||
283 | struct ubifs_inode *ui = ubifs_inode(inode); | ||
284 | |||
285 | ubifs_assert(!ui->xattr); | ||
286 | if (is_bad_inode(inode)) | ||
287 | return 0; | ||
288 | |||
289 | mutex_lock(&ui->ui_mutex); | ||
290 | /* | ||
291 | * Due to races between write-back forced by budgeting | ||
292 | * (see 'sync_some_inodes()') and pdflush write-back, the inode may | ||
293 | * have already been synchronized, do not do this again. This might | ||
294 | * also happen if it was synchronized in an VFS operation, e.g. | ||
295 | * 'ubifs_link()'. | ||
296 | */ | ||
297 | if (!ui->dirty) { | ||
298 | mutex_unlock(&ui->ui_mutex); | ||
299 | return 0; | ||
300 | } | ||
301 | |||
302 | dbg_gen("inode %lu", inode->i_ino); | ||
303 | err = ubifs_jnl_write_inode(c, inode, 0); | ||
304 | if (err) | ||
305 | ubifs_err("can't write inode %lu, error %d", inode->i_ino, err); | ||
306 | |||
307 | ui->dirty = 0; | ||
308 | mutex_unlock(&ui->ui_mutex); | ||
309 | ubifs_release_dirty_inode_budget(c, ui); | ||
310 | return err; | ||
311 | } | ||
312 | |||
313 | static void ubifs_delete_inode(struct inode *inode) | ||
314 | { | ||
315 | int err; | ||
316 | struct ubifs_info *c = inode->i_sb->s_fs_info; | ||
317 | |||
318 | if (ubifs_inode(inode)->xattr) | ||
319 | /* | ||
320 | * Extended attribute inode deletions are fully handled in | ||
321 | * 'ubifs_removexattr()'. These inodes are special and have | ||
322 | * limited usage, so there is nothing to do here. | ||
323 | */ | ||
324 | goto out; | ||
325 | |||
326 | dbg_gen("inode %lu", inode->i_ino); | ||
327 | ubifs_assert(!atomic_read(&inode->i_count)); | ||
328 | ubifs_assert(inode->i_nlink == 0); | ||
329 | |||
330 | truncate_inode_pages(&inode->i_data, 0); | ||
331 | if (is_bad_inode(inode)) | ||
332 | goto out; | ||
333 | |||
334 | ubifs_inode(inode)->ui_size = inode->i_size = 0; | ||
335 | err = ubifs_jnl_write_inode(c, inode, 1); | ||
336 | if (err) | ||
337 | /* | ||
338 | * Worst case we have a lost orphan inode wasting space, so a | ||
339 | * simple error message is ok here. | ||
340 | */ | ||
341 | ubifs_err("can't write inode %lu, error %d", inode->i_ino, err); | ||
342 | out: | ||
343 | clear_inode(inode); | ||
344 | } | ||
345 | |||
346 | static void ubifs_dirty_inode(struct inode *inode) | ||
347 | { | ||
348 | struct ubifs_inode *ui = ubifs_inode(inode); | ||
349 | |||
350 | ubifs_assert(mutex_is_locked(&ui->ui_mutex)); | ||
351 | if (!ui->dirty) { | ||
352 | ui->dirty = 1; | ||
353 | dbg_gen("inode %lu", inode->i_ino); | ||
354 | } | ||
355 | } | ||
356 | |||
357 | static int ubifs_statfs(struct dentry *dentry, struct kstatfs *buf) | ||
358 | { | ||
359 | struct ubifs_info *c = dentry->d_sb->s_fs_info; | ||
360 | unsigned long long free; | ||
361 | |||
362 | free = ubifs_budg_get_free_space(c); | ||
363 | dbg_gen("free space %lld bytes (%lld blocks)", | ||
364 | free, free >> UBIFS_BLOCK_SHIFT); | ||
365 | |||
366 | buf->f_type = UBIFS_SUPER_MAGIC; | ||
367 | buf->f_bsize = UBIFS_BLOCK_SIZE; | ||
368 | buf->f_blocks = c->block_cnt; | ||
369 | buf->f_bfree = free >> UBIFS_BLOCK_SHIFT; | ||
370 | if (free > c->report_rp_size) | ||
371 | buf->f_bavail = (free - c->report_rp_size) >> UBIFS_BLOCK_SHIFT; | ||
372 | else | ||
373 | buf->f_bavail = 0; | ||
374 | buf->f_files = 0; | ||
375 | buf->f_ffree = 0; | ||
376 | buf->f_namelen = UBIFS_MAX_NLEN; | ||
377 | |||
378 | return 0; | ||
379 | } | ||
380 | |||
381 | static int ubifs_show_options(struct seq_file *s, struct vfsmount *mnt) | ||
382 | { | ||
383 | struct ubifs_info *c = mnt->mnt_sb->s_fs_info; | ||
384 | |||
385 | if (c->mount_opts.unmount_mode == 2) | ||
386 | seq_printf(s, ",fast_unmount"); | ||
387 | else if (c->mount_opts.unmount_mode == 1) | ||
388 | seq_printf(s, ",norm_unmount"); | ||
389 | |||
390 | return 0; | ||
391 | } | ||
392 | |||
393 | static int ubifs_sync_fs(struct super_block *sb, int wait) | ||
394 | { | ||
395 | struct ubifs_info *c = sb->s_fs_info; | ||
396 | int i, ret = 0, err; | ||
397 | |||
398 | if (c->jheads) | ||
399 | for (i = 0; i < c->jhead_cnt; i++) { | ||
400 | err = ubifs_wbuf_sync(&c->jheads[i].wbuf); | ||
401 | if (err && !ret) | ||
402 | ret = err; | ||
403 | } | ||
404 | /* | ||
405 | * We ought to call sync for c->ubi but it does not have one. If it had | ||
406 | * it would in turn call mtd->sync, however mtd operations are | ||
407 | * synchronous anyway, so we don't lose any sleep here. | ||
408 | */ | ||
409 | return ret; | ||
410 | } | ||
411 | |||
412 | /** | ||
413 | * init_constants_early - initialize UBIFS constants. | ||
414 | * @c: UBIFS file-system description object | ||
415 | * | ||
416 | * This function initialize UBIFS constants which do not need the superblock to | ||
417 | * be read. It also checks that the UBI volume satisfies basic UBIFS | ||
418 | * requirements. Returns zero in case of success and a negative error code in | ||
419 | * case of failure. | ||
420 | */ | ||
421 | static int init_constants_early(struct ubifs_info *c) | ||
422 | { | ||
423 | if (c->vi.corrupted) { | ||
424 | ubifs_warn("UBI volume is corrupted - read-only mode"); | ||
425 | c->ro_media = 1; | ||
426 | } | ||
427 | |||
428 | if (c->di.ro_mode) { | ||
429 | ubifs_msg("read-only UBI device"); | ||
430 | c->ro_media = 1; | ||
431 | } | ||
432 | |||
433 | if (c->vi.vol_type == UBI_STATIC_VOLUME) { | ||
434 | ubifs_msg("static UBI volume - read-only mode"); | ||
435 | c->ro_media = 1; | ||
436 | } | ||
437 | |||
438 | c->leb_cnt = c->vi.size; | ||
439 | c->leb_size = c->vi.usable_leb_size; | ||
440 | c->half_leb_size = c->leb_size / 2; | ||
441 | c->min_io_size = c->di.min_io_size; | ||
442 | c->min_io_shift = fls(c->min_io_size) - 1; | ||
443 | |||
444 | if (c->leb_size < UBIFS_MIN_LEB_SZ) { | ||
445 | ubifs_err("too small LEBs (%d bytes), min. is %d bytes", | ||
446 | c->leb_size, UBIFS_MIN_LEB_SZ); | ||
447 | return -EINVAL; | ||
448 | } | ||
449 | |||
450 | if (c->leb_cnt < UBIFS_MIN_LEB_CNT) { | ||
451 | ubifs_err("too few LEBs (%d), min. is %d", | ||
452 | c->leb_cnt, UBIFS_MIN_LEB_CNT); | ||
453 | return -EINVAL; | ||
454 | } | ||
455 | |||
456 | if (!is_power_of_2(c->min_io_size)) { | ||
457 | ubifs_err("bad min. I/O size %d", c->min_io_size); | ||
458 | return -EINVAL; | ||
459 | } | ||
460 | |||
461 | /* | ||
462 | * UBIFS aligns all node to 8-byte boundary, so to make function in | ||
463 | * io.c simpler, assume minimum I/O unit size to be 8 bytes if it is | ||
464 | * less than 8. | ||
465 | */ | ||
466 | if (c->min_io_size < 8) { | ||
467 | c->min_io_size = 8; | ||
468 | c->min_io_shift = 3; | ||
469 | } | ||
470 | |||
471 | c->ref_node_alsz = ALIGN(UBIFS_REF_NODE_SZ, c->min_io_size); | ||
472 | c->mst_node_alsz = ALIGN(UBIFS_MST_NODE_SZ, c->min_io_size); | ||
473 | |||
474 | /* | ||
475 | * Initialize node length ranges which are mostly needed for node | ||
476 | * length validation. | ||
477 | */ | ||
478 | c->ranges[UBIFS_PAD_NODE].len = UBIFS_PAD_NODE_SZ; | ||
479 | c->ranges[UBIFS_SB_NODE].len = UBIFS_SB_NODE_SZ; | ||
480 | c->ranges[UBIFS_MST_NODE].len = UBIFS_MST_NODE_SZ; | ||
481 | c->ranges[UBIFS_REF_NODE].len = UBIFS_REF_NODE_SZ; | ||
482 | c->ranges[UBIFS_TRUN_NODE].len = UBIFS_TRUN_NODE_SZ; | ||
483 | c->ranges[UBIFS_CS_NODE].len = UBIFS_CS_NODE_SZ; | ||
484 | |||
485 | c->ranges[UBIFS_INO_NODE].min_len = UBIFS_INO_NODE_SZ; | ||
486 | c->ranges[UBIFS_INO_NODE].max_len = UBIFS_MAX_INO_NODE_SZ; | ||
487 | c->ranges[UBIFS_ORPH_NODE].min_len = | ||
488 | UBIFS_ORPH_NODE_SZ + sizeof(__le64); | ||
489 | c->ranges[UBIFS_ORPH_NODE].max_len = c->leb_size; | ||
490 | c->ranges[UBIFS_DENT_NODE].min_len = UBIFS_DENT_NODE_SZ; | ||
491 | c->ranges[UBIFS_DENT_NODE].max_len = UBIFS_MAX_DENT_NODE_SZ; | ||
492 | c->ranges[UBIFS_XENT_NODE].min_len = UBIFS_XENT_NODE_SZ; | ||
493 | c->ranges[UBIFS_XENT_NODE].max_len = UBIFS_MAX_XENT_NODE_SZ; | ||
494 | c->ranges[UBIFS_DATA_NODE].min_len = UBIFS_DATA_NODE_SZ; | ||
495 | c->ranges[UBIFS_DATA_NODE].max_len = UBIFS_MAX_DATA_NODE_SZ; | ||
496 | /* | ||
497 | * Minimum indexing node size is amended later when superblock is | ||
498 | * read and the key length is known. | ||
499 | */ | ||
500 | c->ranges[UBIFS_IDX_NODE].min_len = UBIFS_IDX_NODE_SZ + UBIFS_BRANCH_SZ; | ||
501 | /* | ||
502 | * Maximum indexing node size is amended later when superblock is | ||
503 | * read and the fanout is known. | ||
504 | */ | ||
505 | c->ranges[UBIFS_IDX_NODE].max_len = INT_MAX; | ||
506 | |||
507 | /* | ||
508 | * Initialize dead and dark LEB space watermarks. | ||
509 | * | ||
510 | * Dead space is the space which cannot be used. Its watermark is | ||
511 | * equivalent to min. I/O unit or minimum node size if it is greater | ||
512 | * then min. I/O unit. | ||
513 | * | ||
514 | * Dark space is the space which might be used, or might not, depending | ||
515 | * on which node should be written to the LEB. Its watermark is | ||
516 | * equivalent to maximum UBIFS node size. | ||
517 | */ | ||
518 | c->dead_wm = ALIGN(MIN_WRITE_SZ, c->min_io_size); | ||
519 | c->dark_wm = ALIGN(UBIFS_MAX_NODE_SZ, c->min_io_size); | ||
520 | |||
521 | return 0; | ||
522 | } | ||
523 | |||
524 | /** | ||
525 | * bud_wbuf_callback - bud LEB write-buffer synchronization call-back. | ||
526 | * @c: UBIFS file-system description object | ||
527 | * @lnum: LEB the write-buffer was synchronized to | ||
528 | * @free: how many free bytes left in this LEB | ||
529 | * @pad: how many bytes were padded | ||
530 | * | ||
531 | * This is a callback function which is called by the I/O unit when the | ||
532 | * write-buffer is synchronized. We need this to correctly maintain space | ||
533 | * accounting in bud logical eraseblocks. This function returns zero in case of | ||
534 | * success and a negative error code in case of failure. | ||
535 | * | ||
536 | * This function actually belongs to the journal, but we keep it here because | ||
537 | * we want to keep it static. | ||
538 | */ | ||
539 | static int bud_wbuf_callback(struct ubifs_info *c, int lnum, int free, int pad) | ||
540 | { | ||
541 | return ubifs_update_one_lp(c, lnum, free, pad, 0, 0); | ||
542 | } | ||
543 | |||
544 | /* | ||
545 | * init_constants_late - initialize UBIFS constants. | ||
546 | * @c: UBIFS file-system description object | ||
547 | * | ||
548 | * This is a helper function which initializes various UBIFS constants after | ||
549 | * the superblock has been read. It also checks various UBIFS parameters and | ||
550 | * makes sure they are all right. Returns zero in case of success and a | ||
551 | * negative error code in case of failure. | ||
552 | */ | ||
553 | static int init_constants_late(struct ubifs_info *c) | ||
554 | { | ||
555 | int tmp, err; | ||
556 | uint64_t tmp64; | ||
557 | |||
558 | c->main_bytes = (long long)c->main_lebs * c->leb_size; | ||
559 | c->max_znode_sz = sizeof(struct ubifs_znode) + | ||
560 | c->fanout * sizeof(struct ubifs_zbranch); | ||
561 | |||
562 | tmp = ubifs_idx_node_sz(c, 1); | ||
563 | c->ranges[UBIFS_IDX_NODE].min_len = tmp; | ||
564 | c->min_idx_node_sz = ALIGN(tmp, 8); | ||
565 | |||
566 | tmp = ubifs_idx_node_sz(c, c->fanout); | ||
567 | c->ranges[UBIFS_IDX_NODE].max_len = tmp; | ||
568 | c->max_idx_node_sz = ALIGN(tmp, 8); | ||
569 | |||
570 | /* Make sure LEB size is large enough to fit full commit */ | ||
571 | tmp = UBIFS_CS_NODE_SZ + UBIFS_REF_NODE_SZ * c->jhead_cnt; | ||
572 | tmp = ALIGN(tmp, c->min_io_size); | ||
573 | if (tmp > c->leb_size) { | ||
574 | dbg_err("too small LEB size %d, at least %d needed", | ||
575 | c->leb_size, tmp); | ||
576 | return -EINVAL; | ||
577 | } | ||
578 | |||
579 | /* | ||
580 | * Make sure that the log is large enough to fit reference nodes for | ||
581 | * all buds plus one reserved LEB. | ||
582 | */ | ||
583 | tmp64 = c->max_bud_bytes; | ||
584 | tmp = do_div(tmp64, c->leb_size); | ||
585 | c->max_bud_cnt = tmp64 + !!tmp; | ||
586 | tmp = (c->ref_node_alsz * c->max_bud_cnt + c->leb_size - 1); | ||
587 | tmp /= c->leb_size; | ||
588 | tmp += 1; | ||
589 | if (c->log_lebs < tmp) { | ||
590 | dbg_err("too small log %d LEBs, required min. %d LEBs", | ||
591 | c->log_lebs, tmp); | ||
592 | return -EINVAL; | ||
593 | } | ||
594 | |||
595 | /* | ||
596 | * When budgeting we assume worst-case scenarios when the pages are not | ||
597 | * be compressed and direntries are of the maximum size. | ||
598 | * | ||
599 | * Note, data, which may be stored in inodes is budgeted separately, so | ||
600 | * it is not included into 'c->inode_budget'. | ||
601 | */ | ||
602 | c->page_budget = UBIFS_MAX_DATA_NODE_SZ * UBIFS_BLOCKS_PER_PAGE; | ||
603 | c->inode_budget = UBIFS_INO_NODE_SZ; | ||
604 | c->dent_budget = UBIFS_MAX_DENT_NODE_SZ; | ||
605 | |||
606 | /* | ||
607 | * When the amount of flash space used by buds becomes | ||
608 | * 'c->max_bud_bytes', UBIFS just blocks all writers and starts commit. | ||
609 | * The writers are unblocked when the commit is finished. To avoid | ||
610 | * writers to be blocked UBIFS initiates background commit in advance, | ||
611 | * when number of bud bytes becomes above the limit defined below. | ||
612 | */ | ||
613 | c->bg_bud_bytes = (c->max_bud_bytes * 13) >> 4; | ||
614 | |||
615 | /* | ||
616 | * Ensure minimum journal size. All the bytes in the journal heads are | ||
617 | * considered to be used, when calculating the current journal usage. | ||
618 | * Consequently, if the journal is too small, UBIFS will treat it as | ||
619 | * always full. | ||
620 | */ | ||
621 | tmp64 = (uint64_t)(c->jhead_cnt + 1) * c->leb_size + 1; | ||
622 | if (c->bg_bud_bytes < tmp64) | ||
623 | c->bg_bud_bytes = tmp64; | ||
624 | if (c->max_bud_bytes < tmp64 + c->leb_size) | ||
625 | c->max_bud_bytes = tmp64 + c->leb_size; | ||
626 | |||
627 | err = ubifs_calc_lpt_geom(c); | ||
628 | if (err) | ||
629 | return err; | ||
630 | |||
631 | c->min_idx_lebs = ubifs_calc_min_idx_lebs(c); | ||
632 | |||
633 | /* | ||
634 | * Calculate total amount of FS blocks. This number is not used | ||
635 | * internally because it does not make much sense for UBIFS, but it is | ||
636 | * necessary to report something for the 'statfs()' call. | ||
637 | * | ||
638 | * Subtract the LEB reserved for GC and the LEB which is reserved for | ||
639 | * deletions. | ||
640 | * | ||
641 | * Review 'ubifs_calc_available()' if changing this calculation. | ||
642 | */ | ||
643 | tmp64 = c->main_lebs - 2; | ||
644 | tmp64 *= (uint64_t)c->leb_size - c->dark_wm; | ||
645 | tmp64 = ubifs_reported_space(c, tmp64); | ||
646 | c->block_cnt = tmp64 >> UBIFS_BLOCK_SHIFT; | ||
647 | |||
648 | return 0; | ||
649 | } | ||
650 | |||
651 | /** | ||
652 | * take_gc_lnum - reserve GC LEB. | ||
653 | * @c: UBIFS file-system description object | ||
654 | * | ||
655 | * This function ensures that the LEB reserved for garbage collection is | ||
656 | * unmapped and is marked as "taken" in lprops. We also have to set free space | ||
657 | * to LEB size and dirty space to zero, because lprops may contain out-of-date | ||
658 | * information if the file-system was un-mounted before it has been committed. | ||
659 | * This function returns zero in case of success and a negative error code in | ||
660 | * case of failure. | ||
661 | */ | ||
662 | static int take_gc_lnum(struct ubifs_info *c) | ||
663 | { | ||
664 | int err; | ||
665 | |||
666 | if (c->gc_lnum == -1) { | ||
667 | ubifs_err("no LEB for GC"); | ||
668 | return -EINVAL; | ||
669 | } | ||
670 | |||
671 | err = ubifs_leb_unmap(c, c->gc_lnum); | ||
672 | if (err) | ||
673 | return err; | ||
674 | |||
675 | /* And we have to tell lprops that this LEB is taken */ | ||
676 | err = ubifs_change_one_lp(c, c->gc_lnum, c->leb_size, 0, | ||
677 | LPROPS_TAKEN, 0, 0); | ||
678 | return err; | ||
679 | } | ||
680 | |||
681 | /** | ||
682 | * alloc_wbufs - allocate write-buffers. | ||
683 | * @c: UBIFS file-system description object | ||
684 | * | ||
685 | * This helper function allocates and initializes UBIFS write-buffers. Returns | ||
686 | * zero in case of success and %-ENOMEM in case of failure. | ||
687 | */ | ||
688 | static int alloc_wbufs(struct ubifs_info *c) | ||
689 | { | ||
690 | int i, err; | ||
691 | |||
692 | c->jheads = kzalloc(c->jhead_cnt * sizeof(struct ubifs_jhead), | ||
693 | GFP_KERNEL); | ||
694 | if (!c->jheads) | ||
695 | return -ENOMEM; | ||
696 | |||
697 | /* Initialize journal heads */ | ||
698 | for (i = 0; i < c->jhead_cnt; i++) { | ||
699 | INIT_LIST_HEAD(&c->jheads[i].buds_list); | ||
700 | err = ubifs_wbuf_init(c, &c->jheads[i].wbuf); | ||
701 | if (err) | ||
702 | return err; | ||
703 | |||
704 | c->jheads[i].wbuf.sync_callback = &bud_wbuf_callback; | ||
705 | c->jheads[i].wbuf.jhead = i; | ||
706 | } | ||
707 | |||
708 | c->jheads[BASEHD].wbuf.dtype = UBI_SHORTTERM; | ||
709 | /* | ||
710 | * Garbage Collector head likely contains long-term data and | ||
711 | * does not need to be synchronized by timer. | ||
712 | */ | ||
713 | c->jheads[GCHD].wbuf.dtype = UBI_LONGTERM; | ||
714 | c->jheads[GCHD].wbuf.timeout = 0; | ||
715 | |||
716 | return 0; | ||
717 | } | ||
718 | |||
719 | /** | ||
720 | * free_wbufs - free write-buffers. | ||
721 | * @c: UBIFS file-system description object | ||
722 | */ | ||
723 | static void free_wbufs(struct ubifs_info *c) | ||
724 | { | ||
725 | int i; | ||
726 | |||
727 | if (c->jheads) { | ||
728 | for (i = 0; i < c->jhead_cnt; i++) { | ||
729 | kfree(c->jheads[i].wbuf.buf); | ||
730 | kfree(c->jheads[i].wbuf.inodes); | ||
731 | } | ||
732 | kfree(c->jheads); | ||
733 | c->jheads = NULL; | ||
734 | } | ||
735 | } | ||
736 | |||
737 | /** | ||
738 | * free_orphans - free orphans. | ||
739 | * @c: UBIFS file-system description object | ||
740 | */ | ||
741 | static void free_orphans(struct ubifs_info *c) | ||
742 | { | ||
743 | struct ubifs_orphan *orph; | ||
744 | |||
745 | while (c->orph_dnext) { | ||
746 | orph = c->orph_dnext; | ||
747 | c->orph_dnext = orph->dnext; | ||
748 | list_del(&orph->list); | ||
749 | kfree(orph); | ||
750 | } | ||
751 | |||
752 | while (!list_empty(&c->orph_list)) { | ||
753 | orph = list_entry(c->orph_list.next, struct ubifs_orphan, list); | ||
754 | list_del(&orph->list); | ||
755 | kfree(orph); | ||
756 | dbg_err("orphan list not empty at unmount"); | ||
757 | } | ||
758 | |||
759 | vfree(c->orph_buf); | ||
760 | c->orph_buf = NULL; | ||
761 | } | ||
762 | |||
763 | /** | ||
764 | * free_buds - free per-bud objects. | ||
765 | * @c: UBIFS file-system description object | ||
766 | */ | ||
767 | static void free_buds(struct ubifs_info *c) | ||
768 | { | ||
769 | struct rb_node *this = c->buds.rb_node; | ||
770 | struct ubifs_bud *bud; | ||
771 | |||
772 | while (this) { | ||
773 | if (this->rb_left) | ||
774 | this = this->rb_left; | ||
775 | else if (this->rb_right) | ||
776 | this = this->rb_right; | ||
777 | else { | ||
778 | bud = rb_entry(this, struct ubifs_bud, rb); | ||
779 | this = rb_parent(this); | ||
780 | if (this) { | ||
781 | if (this->rb_left == &bud->rb) | ||
782 | this->rb_left = NULL; | ||
783 | else | ||
784 | this->rb_right = NULL; | ||
785 | } | ||
786 | kfree(bud); | ||
787 | } | ||
788 | } | ||
789 | } | ||
790 | |||
791 | /** | ||
792 | * check_volume_empty - check if the UBI volume is empty. | ||
793 | * @c: UBIFS file-system description object | ||
794 | * | ||
795 | * This function checks if the UBIFS volume is empty by looking if its LEBs are | ||
796 | * mapped or not. The result of checking is stored in the @c->empty variable. | ||
797 | * Returns zero in case of success and a negative error code in case of | ||
798 | * failure. | ||
799 | */ | ||
800 | static int check_volume_empty(struct ubifs_info *c) | ||
801 | { | ||
802 | int lnum, err; | ||
803 | |||
804 | c->empty = 1; | ||
805 | for (lnum = 0; lnum < c->leb_cnt; lnum++) { | ||
806 | err = ubi_is_mapped(c->ubi, lnum); | ||
807 | if (unlikely(err < 0)) | ||
808 | return err; | ||
809 | if (err == 1) { | ||
810 | c->empty = 0; | ||
811 | break; | ||
812 | } | ||
813 | |||
814 | cond_resched(); | ||
815 | } | ||
816 | |||
817 | return 0; | ||
818 | } | ||
819 | |||
820 | /* | ||
821 | * UBIFS mount options. | ||
822 | * | ||
823 | * Opt_fast_unmount: do not run a journal commit before un-mounting | ||
824 | * Opt_norm_unmount: run a journal commit before un-mounting | ||
825 | * Opt_err: just end of array marker | ||
826 | */ | ||
827 | enum { | ||
828 | Opt_fast_unmount, | ||
829 | Opt_norm_unmount, | ||
830 | Opt_err, | ||
831 | }; | ||
832 | |||
833 | static match_table_t tokens = { | ||
834 | {Opt_fast_unmount, "fast_unmount"}, | ||
835 | {Opt_norm_unmount, "norm_unmount"}, | ||
836 | {Opt_err, NULL}, | ||
837 | }; | ||
838 | |||
839 | /** | ||
840 | * ubifs_parse_options - parse mount parameters. | ||
841 | * @c: UBIFS file-system description object | ||
842 | * @options: parameters to parse | ||
843 | * @is_remount: non-zero if this is FS re-mount | ||
844 | * | ||
845 | * This function parses UBIFS mount options and returns zero in case success | ||
846 | * and a negative error code in case of failure. | ||
847 | */ | ||
848 | static int ubifs_parse_options(struct ubifs_info *c, char *options, | ||
849 | int is_remount) | ||
850 | { | ||
851 | char *p; | ||
852 | substring_t args[MAX_OPT_ARGS]; | ||
853 | |||
854 | if (!options) | ||
855 | return 0; | ||
856 | |||
857 | while ((p = strsep(&options, ","))) { | ||
858 | int token; | ||
859 | |||
860 | if (!*p) | ||
861 | continue; | ||
862 | |||
863 | token = match_token(p, tokens, args); | ||
864 | switch (token) { | ||
865 | case Opt_fast_unmount: | ||
866 | c->mount_opts.unmount_mode = 2; | ||
867 | c->fast_unmount = 1; | ||
868 | break; | ||
869 | case Opt_norm_unmount: | ||
870 | c->mount_opts.unmount_mode = 1; | ||
871 | c->fast_unmount = 0; | ||
872 | break; | ||
873 | default: | ||
874 | ubifs_err("unrecognized mount option \"%s\" " | ||
875 | "or missing value", p); | ||
876 | return -EINVAL; | ||
877 | } | ||
878 | } | ||
879 | |||
880 | return 0; | ||
881 | } | ||
882 | |||
883 | /** | ||
884 | * destroy_journal - destroy journal data structures. | ||
885 | * @c: UBIFS file-system description object | ||
886 | * | ||
887 | * This function destroys journal data structures including those that may have | ||
888 | * been created by recovery functions. | ||
889 | */ | ||
890 | static void destroy_journal(struct ubifs_info *c) | ||
891 | { | ||
892 | while (!list_empty(&c->unclean_leb_list)) { | ||
893 | struct ubifs_unclean_leb *ucleb; | ||
894 | |||
895 | ucleb = list_entry(c->unclean_leb_list.next, | ||
896 | struct ubifs_unclean_leb, list); | ||
897 | list_del(&ucleb->list); | ||
898 | kfree(ucleb); | ||
899 | } | ||
900 | while (!list_empty(&c->old_buds)) { | ||
901 | struct ubifs_bud *bud; | ||
902 | |||
903 | bud = list_entry(c->old_buds.next, struct ubifs_bud, list); | ||
904 | list_del(&bud->list); | ||
905 | kfree(bud); | ||
906 | } | ||
907 | ubifs_destroy_idx_gc(c); | ||
908 | ubifs_destroy_size_tree(c); | ||
909 | ubifs_tnc_close(c); | ||
910 | free_buds(c); | ||
911 | } | ||
912 | |||
913 | /** | ||
914 | * mount_ubifs - mount UBIFS file-system. | ||
915 | * @c: UBIFS file-system description object | ||
916 | * | ||
917 | * This function mounts UBIFS file system. Returns zero in case of success and | ||
918 | * a negative error code in case of failure. | ||
919 | * | ||
920 | * Note, the function does not de-allocate resources it it fails half way | ||
921 | * through, and the caller has to do this instead. | ||
922 | */ | ||
923 | static int mount_ubifs(struct ubifs_info *c) | ||
924 | { | ||
925 | struct super_block *sb = c->vfs_sb; | ||
926 | int err, mounted_read_only = (sb->s_flags & MS_RDONLY); | ||
927 | long long x; | ||
928 | size_t sz; | ||
929 | |||
930 | err = init_constants_early(c); | ||
931 | if (err) | ||
932 | return err; | ||
933 | |||
934 | #ifdef CONFIG_UBIFS_FS_DEBUG | ||
935 | c->dbg_buf = vmalloc(c->leb_size); | ||
936 | if (!c->dbg_buf) | ||
937 | return -ENOMEM; | ||
938 | #endif | ||
939 | |||
940 | err = check_volume_empty(c); | ||
941 | if (err) | ||
942 | goto out_free; | ||
943 | |||
944 | if (c->empty && (mounted_read_only || c->ro_media)) { | ||
945 | /* | ||
946 | * This UBI volume is empty, and read-only, or the file system | ||
947 | * is mounted read-only - we cannot format it. | ||
948 | */ | ||
949 | ubifs_err("can't format empty UBI volume: read-only %s", | ||
950 | c->ro_media ? "UBI volume" : "mount"); | ||
951 | err = -EROFS; | ||
952 | goto out_free; | ||
953 | } | ||
954 | |||
955 | if (c->ro_media && !mounted_read_only) { | ||
956 | ubifs_err("cannot mount read-write - read-only media"); | ||
957 | err = -EROFS; | ||
958 | goto out_free; | ||
959 | } | ||
960 | |||
961 | /* | ||
962 | * The requirement for the buffer is that it should fit indexing B-tree | ||
963 | * height amount of integers. We assume the height if the TNC tree will | ||
964 | * never exceed 64. | ||
965 | */ | ||
966 | err = -ENOMEM; | ||
967 | c->bottom_up_buf = kmalloc(BOTTOM_UP_HEIGHT * sizeof(int), GFP_KERNEL); | ||
968 | if (!c->bottom_up_buf) | ||
969 | goto out_free; | ||
970 | |||
971 | c->sbuf = vmalloc(c->leb_size); | ||
972 | if (!c->sbuf) | ||
973 | goto out_free; | ||
974 | |||
975 | if (!mounted_read_only) { | ||
976 | c->ileb_buf = vmalloc(c->leb_size); | ||
977 | if (!c->ileb_buf) | ||
978 | goto out_free; | ||
979 | } | ||
980 | |||
981 | err = ubifs_read_superblock(c); | ||
982 | if (err) | ||
983 | goto out_free; | ||
984 | |||
985 | /* | ||
986 | * Make sure the compressor which is set as the default on in the | ||
987 | * superblock was actually compiled in. | ||
988 | */ | ||
989 | if (!ubifs_compr_present(c->default_compr)) { | ||
990 | ubifs_warn("'%s' compressor is set by superblock, but not " | ||
991 | "compiled in", ubifs_compr_name(c->default_compr)); | ||
992 | c->default_compr = UBIFS_COMPR_NONE; | ||
993 | } | ||
994 | |||
995 | dbg_failure_mode_registration(c); | ||
996 | |||
997 | err = init_constants_late(c); | ||
998 | if (err) | ||
999 | goto out_dereg; | ||
1000 | |||
1001 | sz = ALIGN(c->max_idx_node_sz, c->min_io_size); | ||
1002 | sz = ALIGN(sz + c->max_idx_node_sz, c->min_io_size); | ||
1003 | c->cbuf = kmalloc(sz, GFP_NOFS); | ||
1004 | if (!c->cbuf) { | ||
1005 | err = -ENOMEM; | ||
1006 | goto out_dereg; | ||
1007 | } | ||
1008 | |||
1009 | if (!mounted_read_only) { | ||
1010 | err = alloc_wbufs(c); | ||
1011 | if (err) | ||
1012 | goto out_cbuf; | ||
1013 | |||
1014 | /* Create background thread */ | ||
1015 | sprintf(c->bgt_name, BGT_NAME_PATTERN, c->vi.ubi_num, | ||
1016 | c->vi.vol_id); | ||
1017 | c->bgt = kthread_create(ubifs_bg_thread, c, c->bgt_name); | ||
1018 | if (!c->bgt) | ||
1019 | c->bgt = ERR_PTR(-EINVAL); | ||
1020 | if (IS_ERR(c->bgt)) { | ||
1021 | err = PTR_ERR(c->bgt); | ||
1022 | c->bgt = NULL; | ||
1023 | ubifs_err("cannot spawn \"%s\", error %d", | ||
1024 | c->bgt_name, err); | ||
1025 | goto out_wbufs; | ||
1026 | } | ||
1027 | wake_up_process(c->bgt); | ||
1028 | } | ||
1029 | |||
1030 | err = ubifs_read_master(c); | ||
1031 | if (err) | ||
1032 | goto out_master; | ||
1033 | |||
1034 | if ((c->mst_node->flags & cpu_to_le32(UBIFS_MST_DIRTY)) != 0) { | ||
1035 | ubifs_msg("recovery needed"); | ||
1036 | c->need_recovery = 1; | ||
1037 | if (!mounted_read_only) { | ||
1038 | err = ubifs_recover_inl_heads(c, c->sbuf); | ||
1039 | if (err) | ||
1040 | goto out_master; | ||
1041 | } | ||
1042 | } else if (!mounted_read_only) { | ||
1043 | /* | ||
1044 | * Set the "dirty" flag so that if we reboot uncleanly we | ||
1045 | * will notice this immediately on the next mount. | ||
1046 | */ | ||
1047 | c->mst_node->flags |= cpu_to_le32(UBIFS_MST_DIRTY); | ||
1048 | err = ubifs_write_master(c); | ||
1049 | if (err) | ||
1050 | goto out_master; | ||
1051 | } | ||
1052 | |||
1053 | err = ubifs_lpt_init(c, 1, !mounted_read_only); | ||
1054 | if (err) | ||
1055 | goto out_lpt; | ||
1056 | |||
1057 | err = dbg_check_idx_size(c, c->old_idx_sz); | ||
1058 | if (err) | ||
1059 | goto out_lpt; | ||
1060 | |||
1061 | err = ubifs_replay_journal(c); | ||
1062 | if (err) | ||
1063 | goto out_journal; | ||
1064 | |||
1065 | err = ubifs_mount_orphans(c, c->need_recovery, mounted_read_only); | ||
1066 | if (err) | ||
1067 | goto out_orphans; | ||
1068 | |||
1069 | if (!mounted_read_only) { | ||
1070 | int lnum; | ||
1071 | |||
1072 | /* Check for enough free space */ | ||
1073 | if (ubifs_calc_available(c, c->min_idx_lebs) <= 0) { | ||
1074 | ubifs_err("insufficient available space"); | ||
1075 | err = -EINVAL; | ||
1076 | goto out_orphans; | ||
1077 | } | ||
1078 | |||
1079 | /* Check for enough log space */ | ||
1080 | lnum = c->lhead_lnum + 1; | ||
1081 | if (lnum >= UBIFS_LOG_LNUM + c->log_lebs) | ||
1082 | lnum = UBIFS_LOG_LNUM; | ||
1083 | if (lnum == c->ltail_lnum) { | ||
1084 | err = ubifs_consolidate_log(c); | ||
1085 | if (err) | ||
1086 | goto out_orphans; | ||
1087 | } | ||
1088 | |||
1089 | if (c->need_recovery) { | ||
1090 | err = ubifs_recover_size(c); | ||
1091 | if (err) | ||
1092 | goto out_orphans; | ||
1093 | err = ubifs_rcvry_gc_commit(c); | ||
1094 | } else | ||
1095 | err = take_gc_lnum(c); | ||
1096 | if (err) | ||
1097 | goto out_orphans; | ||
1098 | |||
1099 | err = dbg_check_lprops(c); | ||
1100 | if (err) | ||
1101 | goto out_orphans; | ||
1102 | } else if (c->need_recovery) { | ||
1103 | err = ubifs_recover_size(c); | ||
1104 | if (err) | ||
1105 | goto out_orphans; | ||
1106 | } | ||
1107 | |||
1108 | spin_lock(&ubifs_infos_lock); | ||
1109 | list_add_tail(&c->infos_list, &ubifs_infos); | ||
1110 | spin_unlock(&ubifs_infos_lock); | ||
1111 | |||
1112 | if (c->need_recovery) { | ||
1113 | if (mounted_read_only) | ||
1114 | ubifs_msg("recovery deferred"); | ||
1115 | else { | ||
1116 | c->need_recovery = 0; | ||
1117 | ubifs_msg("recovery completed"); | ||
1118 | } | ||
1119 | } | ||
1120 | |||
1121 | err = dbg_check_filesystem(c); | ||
1122 | if (err) | ||
1123 | goto out_infos; | ||
1124 | |||
1125 | ubifs_msg("mounted UBI device %d, volume %d", c->vi.ubi_num, | ||
1126 | c->vi.vol_id); | ||
1127 | if (mounted_read_only) | ||
1128 | ubifs_msg("mounted read-only"); | ||
1129 | x = (long long)c->main_lebs * c->leb_size; | ||
1130 | ubifs_msg("file system size: %lld bytes (%lld KiB, %lld MiB, %d LEBs)", | ||
1131 | x, x >> 10, x >> 20, c->main_lebs); | ||
1132 | x = (long long)c->log_lebs * c->leb_size + c->max_bud_bytes; | ||
1133 | ubifs_msg("journal size: %lld bytes (%lld KiB, %lld MiB, %d LEBs)", | ||
1134 | x, x >> 10, x >> 20, c->log_lebs + c->max_bud_cnt); | ||
1135 | ubifs_msg("default compressor: %s", ubifs_compr_name(c->default_compr)); | ||
1136 | ubifs_msg("media format %d, latest format %d", | ||
1137 | c->fmt_version, UBIFS_FORMAT_VERSION); | ||
1138 | |||
1139 | dbg_msg("compiled on: " __DATE__ " at " __TIME__); | ||
1140 | dbg_msg("min. I/O unit size: %d bytes", c->min_io_size); | ||
1141 | dbg_msg("LEB size: %d bytes (%d KiB)", | ||
1142 | c->leb_size, c->leb_size / 1024); | ||
1143 | dbg_msg("data journal heads: %d", | ||
1144 | c->jhead_cnt - NONDATA_JHEADS_CNT); | ||
1145 | dbg_msg("UUID: %02X%02X%02X%02X-%02X%02X" | ||
1146 | "-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X", | ||
1147 | c->uuid[0], c->uuid[1], c->uuid[2], c->uuid[3], | ||
1148 | c->uuid[4], c->uuid[5], c->uuid[6], c->uuid[7], | ||
1149 | c->uuid[8], c->uuid[9], c->uuid[10], c->uuid[11], | ||
1150 | c->uuid[12], c->uuid[13], c->uuid[14], c->uuid[15]); | ||
1151 | dbg_msg("fast unmount: %d", c->fast_unmount); | ||
1152 | dbg_msg("big_lpt %d", c->big_lpt); | ||
1153 | dbg_msg("log LEBs: %d (%d - %d)", | ||
1154 | c->log_lebs, UBIFS_LOG_LNUM, c->log_last); | ||
1155 | dbg_msg("LPT area LEBs: %d (%d - %d)", | ||
1156 | c->lpt_lebs, c->lpt_first, c->lpt_last); | ||
1157 | dbg_msg("orphan area LEBs: %d (%d - %d)", | ||
1158 | c->orph_lebs, c->orph_first, c->orph_last); | ||
1159 | dbg_msg("main area LEBs: %d (%d - %d)", | ||
1160 | c->main_lebs, c->main_first, c->leb_cnt - 1); | ||
1161 | dbg_msg("index LEBs: %d", c->lst.idx_lebs); | ||
1162 | dbg_msg("total index bytes: %lld (%lld KiB, %lld MiB)", | ||
1163 | c->old_idx_sz, c->old_idx_sz >> 10, c->old_idx_sz >> 20); | ||
1164 | dbg_msg("key hash type: %d", c->key_hash_type); | ||
1165 | dbg_msg("tree fanout: %d", c->fanout); | ||
1166 | dbg_msg("reserved GC LEB: %d", c->gc_lnum); | ||
1167 | dbg_msg("first main LEB: %d", c->main_first); | ||
1168 | dbg_msg("dead watermark: %d", c->dead_wm); | ||
1169 | dbg_msg("dark watermark: %d", c->dark_wm); | ||
1170 | x = (long long)c->main_lebs * c->dark_wm; | ||
1171 | dbg_msg("max. dark space: %lld (%lld KiB, %lld MiB)", | ||
1172 | x, x >> 10, x >> 20); | ||
1173 | dbg_msg("maximum bud bytes: %lld (%lld KiB, %lld MiB)", | ||
1174 | c->max_bud_bytes, c->max_bud_bytes >> 10, | ||
1175 | c->max_bud_bytes >> 20); | ||
1176 | dbg_msg("BG commit bud bytes: %lld (%lld KiB, %lld MiB)", | ||
1177 | c->bg_bud_bytes, c->bg_bud_bytes >> 10, | ||
1178 | c->bg_bud_bytes >> 20); | ||
1179 | dbg_msg("current bud bytes %lld (%lld KiB, %lld MiB)", | ||
1180 | c->bud_bytes, c->bud_bytes >> 10, c->bud_bytes >> 20); | ||
1181 | dbg_msg("max. seq. number: %llu", c->max_sqnum); | ||
1182 | dbg_msg("commit number: %llu", c->cmt_no); | ||
1183 | |||
1184 | return 0; | ||
1185 | |||
1186 | out_infos: | ||
1187 | spin_lock(&ubifs_infos_lock); | ||
1188 | list_del(&c->infos_list); | ||
1189 | spin_unlock(&ubifs_infos_lock); | ||
1190 | out_orphans: | ||
1191 | free_orphans(c); | ||
1192 | out_journal: | ||
1193 | destroy_journal(c); | ||
1194 | out_lpt: | ||
1195 | ubifs_lpt_free(c, 0); | ||
1196 | out_master: | ||
1197 | kfree(c->mst_node); | ||
1198 | kfree(c->rcvrd_mst_node); | ||
1199 | if (c->bgt) | ||
1200 | kthread_stop(c->bgt); | ||
1201 | out_wbufs: | ||
1202 | free_wbufs(c); | ||
1203 | out_cbuf: | ||
1204 | kfree(c->cbuf); | ||
1205 | out_dereg: | ||
1206 | dbg_failure_mode_deregistration(c); | ||
1207 | out_free: | ||
1208 | vfree(c->ileb_buf); | ||
1209 | vfree(c->sbuf); | ||
1210 | kfree(c->bottom_up_buf); | ||
1211 | UBIFS_DBG(vfree(c->dbg_buf)); | ||
1212 | return err; | ||
1213 | } | ||
1214 | |||
1215 | /** | ||
1216 | * ubifs_umount - un-mount UBIFS file-system. | ||
1217 | * @c: UBIFS file-system description object | ||
1218 | * | ||
1219 | * Note, this function is called to free allocated resourced when un-mounting, | ||
1220 | * as well as free resources when an error occurred while we were half way | ||
1221 | * through mounting (error path cleanup function). So it has to make sure the | ||
1222 | * resource was actually allocated before freeing it. | ||
1223 | */ | ||
1224 | static void ubifs_umount(struct ubifs_info *c) | ||
1225 | { | ||
1226 | dbg_gen("un-mounting UBI device %d, volume %d", c->vi.ubi_num, | ||
1227 | c->vi.vol_id); | ||
1228 | |||
1229 | spin_lock(&ubifs_infos_lock); | ||
1230 | list_del(&c->infos_list); | ||
1231 | spin_unlock(&ubifs_infos_lock); | ||
1232 | |||
1233 | if (c->bgt) | ||
1234 | kthread_stop(c->bgt); | ||
1235 | |||
1236 | destroy_journal(c); | ||
1237 | free_wbufs(c); | ||
1238 | free_orphans(c); | ||
1239 | ubifs_lpt_free(c, 0); | ||
1240 | |||
1241 | kfree(c->cbuf); | ||
1242 | kfree(c->rcvrd_mst_node); | ||
1243 | kfree(c->mst_node); | ||
1244 | vfree(c->sbuf); | ||
1245 | kfree(c->bottom_up_buf); | ||
1246 | UBIFS_DBG(vfree(c->dbg_buf)); | ||
1247 | vfree(c->ileb_buf); | ||
1248 | dbg_failure_mode_deregistration(c); | ||
1249 | } | ||
1250 | |||
1251 | /** | ||
1252 | * ubifs_remount_rw - re-mount in read-write mode. | ||
1253 | * @c: UBIFS file-system description object | ||
1254 | * | ||
1255 | * UBIFS avoids allocating many unnecessary resources when mounted in read-only | ||
1256 | * mode. This function allocates the needed resources and re-mounts UBIFS in | ||
1257 | * read-write mode. | ||
1258 | */ | ||
1259 | static int ubifs_remount_rw(struct ubifs_info *c) | ||
1260 | { | ||
1261 | int err, lnum; | ||
1262 | |||
1263 | if (c->ro_media) | ||
1264 | return -EINVAL; | ||
1265 | |||
1266 | mutex_lock(&c->umount_mutex); | ||
1267 | c->remounting_rw = 1; | ||
1268 | |||
1269 | /* Check for enough free space */ | ||
1270 | if (ubifs_calc_available(c, c->min_idx_lebs) <= 0) { | ||
1271 | ubifs_err("insufficient available space"); | ||
1272 | err = -EINVAL; | ||
1273 | goto out; | ||
1274 | } | ||
1275 | |||
1276 | if (c->old_leb_cnt != c->leb_cnt) { | ||
1277 | struct ubifs_sb_node *sup; | ||
1278 | |||
1279 | sup = ubifs_read_sb_node(c); | ||
1280 | if (IS_ERR(sup)) { | ||
1281 | err = PTR_ERR(sup); | ||
1282 | goto out; | ||
1283 | } | ||
1284 | sup->leb_cnt = cpu_to_le32(c->leb_cnt); | ||
1285 | err = ubifs_write_sb_node(c, sup); | ||
1286 | if (err) | ||
1287 | goto out; | ||
1288 | } | ||
1289 | |||
1290 | if (c->need_recovery) { | ||
1291 | ubifs_msg("completing deferred recovery"); | ||
1292 | err = ubifs_write_rcvrd_mst_node(c); | ||
1293 | if (err) | ||
1294 | goto out; | ||
1295 | err = ubifs_recover_size(c); | ||
1296 | if (err) | ||
1297 | goto out; | ||
1298 | err = ubifs_clean_lebs(c, c->sbuf); | ||
1299 | if (err) | ||
1300 | goto out; | ||
1301 | err = ubifs_recover_inl_heads(c, c->sbuf); | ||
1302 | if (err) | ||
1303 | goto out; | ||
1304 | } | ||
1305 | |||
1306 | if (!(c->mst_node->flags & cpu_to_le32(UBIFS_MST_DIRTY))) { | ||
1307 | c->mst_node->flags |= cpu_to_le32(UBIFS_MST_DIRTY); | ||
1308 | err = ubifs_write_master(c); | ||
1309 | if (err) | ||
1310 | goto out; | ||
1311 | } | ||
1312 | |||
1313 | c->ileb_buf = vmalloc(c->leb_size); | ||
1314 | if (!c->ileb_buf) { | ||
1315 | err = -ENOMEM; | ||
1316 | goto out; | ||
1317 | } | ||
1318 | |||
1319 | err = ubifs_lpt_init(c, 0, 1); | ||
1320 | if (err) | ||
1321 | goto out; | ||
1322 | |||
1323 | err = alloc_wbufs(c); | ||
1324 | if (err) | ||
1325 | goto out; | ||
1326 | |||
1327 | ubifs_create_buds_lists(c); | ||
1328 | |||
1329 | /* Create background thread */ | ||
1330 | c->bgt = kthread_create(ubifs_bg_thread, c, c->bgt_name); | ||
1331 | if (!c->bgt) | ||
1332 | c->bgt = ERR_PTR(-EINVAL); | ||
1333 | if (IS_ERR(c->bgt)) { | ||
1334 | err = PTR_ERR(c->bgt); | ||
1335 | c->bgt = NULL; | ||
1336 | ubifs_err("cannot spawn \"%s\", error %d", | ||
1337 | c->bgt_name, err); | ||
1338 | return err; | ||
1339 | } | ||
1340 | wake_up_process(c->bgt); | ||
1341 | |||
1342 | c->orph_buf = vmalloc(c->leb_size); | ||
1343 | if (!c->orph_buf) | ||
1344 | return -ENOMEM; | ||
1345 | |||
1346 | /* Check for enough log space */ | ||
1347 | lnum = c->lhead_lnum + 1; | ||
1348 | if (lnum >= UBIFS_LOG_LNUM + c->log_lebs) | ||
1349 | lnum = UBIFS_LOG_LNUM; | ||
1350 | if (lnum == c->ltail_lnum) { | ||
1351 | err = ubifs_consolidate_log(c); | ||
1352 | if (err) | ||
1353 | goto out; | ||
1354 | } | ||
1355 | |||
1356 | if (c->need_recovery) | ||
1357 | err = ubifs_rcvry_gc_commit(c); | ||
1358 | else | ||
1359 | err = take_gc_lnum(c); | ||
1360 | if (err) | ||
1361 | goto out; | ||
1362 | |||
1363 | if (c->need_recovery) { | ||
1364 | c->need_recovery = 0; | ||
1365 | ubifs_msg("deferred recovery completed"); | ||
1366 | } | ||
1367 | |||
1368 | dbg_gen("re-mounted read-write"); | ||
1369 | c->vfs_sb->s_flags &= ~MS_RDONLY; | ||
1370 | c->remounting_rw = 0; | ||
1371 | mutex_unlock(&c->umount_mutex); | ||
1372 | return 0; | ||
1373 | |||
1374 | out: | ||
1375 | vfree(c->orph_buf); | ||
1376 | c->orph_buf = NULL; | ||
1377 | if (c->bgt) { | ||
1378 | kthread_stop(c->bgt); | ||
1379 | c->bgt = NULL; | ||
1380 | } | ||
1381 | free_wbufs(c); | ||
1382 | vfree(c->ileb_buf); | ||
1383 | c->ileb_buf = NULL; | ||
1384 | ubifs_lpt_free(c, 1); | ||
1385 | c->remounting_rw = 0; | ||
1386 | mutex_unlock(&c->umount_mutex); | ||
1387 | return err; | ||
1388 | } | ||
1389 | |||
1390 | /** | ||
1391 | * commit_on_unmount - commit the journal when un-mounting. | ||
1392 | * @c: UBIFS file-system description object | ||
1393 | * | ||
1394 | * This function is called during un-mounting and it commits the journal unless | ||
1395 | * the "fast unmount" mode is enabled. It also avoids committing the journal if | ||
1396 | * it contains too few data. | ||
1397 | * | ||
1398 | * Sometimes recovery requires the journal to be committed at least once, and | ||
1399 | * this function takes care about this. | ||
1400 | */ | ||
1401 | static void commit_on_unmount(struct ubifs_info *c) | ||
1402 | { | ||
1403 | if (!c->fast_unmount) { | ||
1404 | long long bud_bytes; | ||
1405 | |||
1406 | spin_lock(&c->buds_lock); | ||
1407 | bud_bytes = c->bud_bytes; | ||
1408 | spin_unlock(&c->buds_lock); | ||
1409 | if (bud_bytes > c->leb_size) | ||
1410 | ubifs_run_commit(c); | ||
1411 | } | ||
1412 | } | ||
1413 | |||
1414 | /** | ||
1415 | * ubifs_remount_ro - re-mount in read-only mode. | ||
1416 | * @c: UBIFS file-system description object | ||
1417 | * | ||
1418 | * We rely on VFS to have stopped writing. Possibly the background thread could | ||
1419 | * be running a commit, however kthread_stop will wait in that case. | ||
1420 | */ | ||
1421 | static void ubifs_remount_ro(struct ubifs_info *c) | ||
1422 | { | ||
1423 | int i, err; | ||
1424 | |||
1425 | ubifs_assert(!c->need_recovery); | ||
1426 | commit_on_unmount(c); | ||
1427 | |||
1428 | mutex_lock(&c->umount_mutex); | ||
1429 | if (c->bgt) { | ||
1430 | kthread_stop(c->bgt); | ||
1431 | c->bgt = NULL; | ||
1432 | } | ||
1433 | |||
1434 | for (i = 0; i < c->jhead_cnt; i++) { | ||
1435 | ubifs_wbuf_sync(&c->jheads[i].wbuf); | ||
1436 | del_timer_sync(&c->jheads[i].wbuf.timer); | ||
1437 | } | ||
1438 | |||
1439 | if (!c->ro_media) { | ||
1440 | c->mst_node->flags &= ~cpu_to_le32(UBIFS_MST_DIRTY); | ||
1441 | c->mst_node->flags |= cpu_to_le32(UBIFS_MST_NO_ORPHS); | ||
1442 | c->mst_node->gc_lnum = cpu_to_le32(c->gc_lnum); | ||
1443 | err = ubifs_write_master(c); | ||
1444 | if (err) | ||
1445 | ubifs_ro_mode(c, err); | ||
1446 | } | ||
1447 | |||
1448 | ubifs_destroy_idx_gc(c); | ||
1449 | free_wbufs(c); | ||
1450 | vfree(c->orph_buf); | ||
1451 | c->orph_buf = NULL; | ||
1452 | vfree(c->ileb_buf); | ||
1453 | c->ileb_buf = NULL; | ||
1454 | ubifs_lpt_free(c, 1); | ||
1455 | mutex_unlock(&c->umount_mutex); | ||
1456 | } | ||
1457 | |||
1458 | static void ubifs_put_super(struct super_block *sb) | ||
1459 | { | ||
1460 | int i; | ||
1461 | struct ubifs_info *c = sb->s_fs_info; | ||
1462 | |||
1463 | ubifs_msg("un-mount UBI device %d, volume %d", c->vi.ubi_num, | ||
1464 | c->vi.vol_id); | ||
1465 | /* | ||
1466 | * The following asserts are only valid if there has not been a failure | ||
1467 | * of the media. For example, there will be dirty inodes if we failed | ||
1468 | * to write them back because of I/O errors. | ||
1469 | */ | ||
1470 | ubifs_assert(atomic_long_read(&c->dirty_pg_cnt) == 0); | ||
1471 | ubifs_assert(c->budg_idx_growth == 0); | ||
1472 | ubifs_assert(c->budg_data_growth == 0); | ||
1473 | |||
1474 | /* | ||
1475 | * The 'c->umount_lock' prevents races between UBIFS memory shrinker | ||
1476 | * and file system un-mount. Namely, it prevents the shrinker from | ||
1477 | * picking this superblock for shrinking - it will be just skipped if | ||
1478 | * the mutex is locked. | ||
1479 | */ | ||
1480 | mutex_lock(&c->umount_mutex); | ||
1481 | if (!(c->vfs_sb->s_flags & MS_RDONLY)) { | ||
1482 | /* | ||
1483 | * First of all kill the background thread to make sure it does | ||
1484 | * not interfere with un-mounting and freeing resources. | ||
1485 | */ | ||
1486 | if (c->bgt) { | ||
1487 | kthread_stop(c->bgt); | ||
1488 | c->bgt = NULL; | ||
1489 | } | ||
1490 | |||
1491 | /* Synchronize write-buffers */ | ||
1492 | if (c->jheads) | ||
1493 | for (i = 0; i < c->jhead_cnt; i++) { | ||
1494 | ubifs_wbuf_sync(&c->jheads[i].wbuf); | ||
1495 | del_timer_sync(&c->jheads[i].wbuf.timer); | ||
1496 | } | ||
1497 | |||
1498 | /* | ||
1499 | * On fatal errors c->ro_media is set to 1, in which case we do | ||
1500 | * not write the master node. | ||
1501 | */ | ||
1502 | if (!c->ro_media) { | ||
1503 | /* | ||
1504 | * We are being cleanly unmounted which means the | ||
1505 | * orphans were killed - indicate this in the master | ||
1506 | * node. Also save the reserved GC LEB number. | ||
1507 | */ | ||
1508 | int err; | ||
1509 | |||
1510 | c->mst_node->flags &= ~cpu_to_le32(UBIFS_MST_DIRTY); | ||
1511 | c->mst_node->flags |= cpu_to_le32(UBIFS_MST_NO_ORPHS); | ||
1512 | c->mst_node->gc_lnum = cpu_to_le32(c->gc_lnum); | ||
1513 | err = ubifs_write_master(c); | ||
1514 | if (err) | ||
1515 | /* | ||
1516 | * Recovery will attempt to fix the master area | ||
1517 | * next mount, so we just print a message and | ||
1518 | * continue to unmount normally. | ||
1519 | */ | ||
1520 | ubifs_err("failed to write master node, " | ||
1521 | "error %d", err); | ||
1522 | } | ||
1523 | } | ||
1524 | |||
1525 | ubifs_umount(c); | ||
1526 | bdi_destroy(&c->bdi); | ||
1527 | ubi_close_volume(c->ubi); | ||
1528 | mutex_unlock(&c->umount_mutex); | ||
1529 | kfree(c); | ||
1530 | } | ||
1531 | |||
1532 | static int ubifs_remount_fs(struct super_block *sb, int *flags, char *data) | ||
1533 | { | ||
1534 | int err; | ||
1535 | struct ubifs_info *c = sb->s_fs_info; | ||
1536 | |||
1537 | dbg_gen("old flags %#lx, new flags %#x", sb->s_flags, *flags); | ||
1538 | |||
1539 | err = ubifs_parse_options(c, data, 1); | ||
1540 | if (err) { | ||
1541 | ubifs_err("invalid or unknown remount parameter"); | ||
1542 | return err; | ||
1543 | } | ||
1544 | if ((sb->s_flags & MS_RDONLY) && !(*flags & MS_RDONLY)) { | ||
1545 | err = ubifs_remount_rw(c); | ||
1546 | if (err) | ||
1547 | return err; | ||
1548 | } else if (!(sb->s_flags & MS_RDONLY) && (*flags & MS_RDONLY)) | ||
1549 | ubifs_remount_ro(c); | ||
1550 | |||
1551 | return 0; | ||
1552 | } | ||
1553 | |||
1554 | struct super_operations ubifs_super_operations = { | ||
1555 | .alloc_inode = ubifs_alloc_inode, | ||
1556 | .destroy_inode = ubifs_destroy_inode, | ||
1557 | .put_super = ubifs_put_super, | ||
1558 | .write_inode = ubifs_write_inode, | ||
1559 | .delete_inode = ubifs_delete_inode, | ||
1560 | .statfs = ubifs_statfs, | ||
1561 | .dirty_inode = ubifs_dirty_inode, | ||
1562 | .remount_fs = ubifs_remount_fs, | ||
1563 | .show_options = ubifs_show_options, | ||
1564 | .sync_fs = ubifs_sync_fs, | ||
1565 | }; | ||
1566 | |||
1567 | /** | ||
1568 | * open_ubi - parse UBI device name string and open the UBI device. | ||
1569 | * @name: UBI volume name | ||
1570 | * @mode: UBI volume open mode | ||
1571 | * | ||
1572 | * There are several ways to specify UBI volumes when mounting UBIFS: | ||
1573 | * o ubiX_Y - UBI device number X, volume Y; | ||
1574 | * o ubiY - UBI device number 0, volume Y; | ||
1575 | * o ubiX:NAME - mount UBI device X, volume with name NAME; | ||
1576 | * o ubi:NAME - mount UBI device 0, volume with name NAME. | ||
1577 | * | ||
1578 | * Alternative '!' separator may be used instead of ':' (because some shells | ||
1579 | * like busybox may interpret ':' as an NFS host name separator). This function | ||
1580 | * returns ubi volume object in case of success and a negative error code in | ||
1581 | * case of failure. | ||
1582 | */ | ||
1583 | static struct ubi_volume_desc *open_ubi(const char *name, int mode) | ||
1584 | { | ||
1585 | int dev, vol; | ||
1586 | char *endptr; | ||
1587 | |||
1588 | if (name[0] != 'u' || name[1] != 'b' || name[2] != 'i') | ||
1589 | return ERR_PTR(-EINVAL); | ||
1590 | |||
1591 | /* ubi:NAME method */ | ||
1592 | if ((name[3] == ':' || name[3] == '!') && name[4] != '\0') | ||
1593 | return ubi_open_volume_nm(0, name + 4, mode); | ||
1594 | |||
1595 | if (!isdigit(name[3])) | ||
1596 | return ERR_PTR(-EINVAL); | ||
1597 | |||
1598 | dev = simple_strtoul(name + 3, &endptr, 0); | ||
1599 | |||
1600 | /* ubiY method */ | ||
1601 | if (*endptr == '\0') | ||
1602 | return ubi_open_volume(0, dev, mode); | ||
1603 | |||
1604 | /* ubiX_Y method */ | ||
1605 | if (*endptr == '_' && isdigit(endptr[1])) { | ||
1606 | vol = simple_strtoul(endptr + 1, &endptr, 0); | ||
1607 | if (*endptr != '\0') | ||
1608 | return ERR_PTR(-EINVAL); | ||
1609 | return ubi_open_volume(dev, vol, mode); | ||
1610 | } | ||
1611 | |||
1612 | /* ubiX:NAME method */ | ||
1613 | if ((*endptr == ':' || *endptr == '!') && endptr[1] != '\0') | ||
1614 | return ubi_open_volume_nm(dev, ++endptr, mode); | ||
1615 | |||
1616 | return ERR_PTR(-EINVAL); | ||
1617 | } | ||
1618 | |||
1619 | static int ubifs_fill_super(struct super_block *sb, void *data, int silent) | ||
1620 | { | ||
1621 | struct ubi_volume_desc *ubi = sb->s_fs_info; | ||
1622 | struct ubifs_info *c; | ||
1623 | struct inode *root; | ||
1624 | int err; | ||
1625 | |||
1626 | c = kzalloc(sizeof(struct ubifs_info), GFP_KERNEL); | ||
1627 | if (!c) | ||
1628 | return -ENOMEM; | ||
1629 | |||
1630 | spin_lock_init(&c->cnt_lock); | ||
1631 | spin_lock_init(&c->cs_lock); | ||
1632 | spin_lock_init(&c->buds_lock); | ||
1633 | spin_lock_init(&c->space_lock); | ||
1634 | spin_lock_init(&c->orphan_lock); | ||
1635 | init_rwsem(&c->commit_sem); | ||
1636 | mutex_init(&c->lp_mutex); | ||
1637 | mutex_init(&c->tnc_mutex); | ||
1638 | mutex_init(&c->log_mutex); | ||
1639 | mutex_init(&c->mst_mutex); | ||
1640 | mutex_init(&c->umount_mutex); | ||
1641 | init_waitqueue_head(&c->cmt_wq); | ||
1642 | c->buds = RB_ROOT; | ||
1643 | c->old_idx = RB_ROOT; | ||
1644 | c->size_tree = RB_ROOT; | ||
1645 | c->orph_tree = RB_ROOT; | ||
1646 | INIT_LIST_HEAD(&c->infos_list); | ||
1647 | INIT_LIST_HEAD(&c->idx_gc); | ||
1648 | INIT_LIST_HEAD(&c->replay_list); | ||
1649 | INIT_LIST_HEAD(&c->replay_buds); | ||
1650 | INIT_LIST_HEAD(&c->uncat_list); | ||
1651 | INIT_LIST_HEAD(&c->empty_list); | ||
1652 | INIT_LIST_HEAD(&c->freeable_list); | ||
1653 | INIT_LIST_HEAD(&c->frdi_idx_list); | ||
1654 | INIT_LIST_HEAD(&c->unclean_leb_list); | ||
1655 | INIT_LIST_HEAD(&c->old_buds); | ||
1656 | INIT_LIST_HEAD(&c->orph_list); | ||
1657 | INIT_LIST_HEAD(&c->orph_new); | ||
1658 | |||
1659 | c->highest_inum = UBIFS_FIRST_INO; | ||
1660 | get_random_bytes(&c->vfs_gen, sizeof(int)); | ||
1661 | c->lhead_lnum = c->ltail_lnum = UBIFS_LOG_LNUM; | ||
1662 | |||
1663 | ubi_get_volume_info(ubi, &c->vi); | ||
1664 | ubi_get_device_info(c->vi.ubi_num, &c->di); | ||
1665 | |||
1666 | /* Re-open the UBI device in read-write mode */ | ||
1667 | c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READWRITE); | ||
1668 | if (IS_ERR(c->ubi)) { | ||
1669 | err = PTR_ERR(c->ubi); | ||
1670 | goto out_free; | ||
1671 | } | ||
1672 | |||
1673 | /* | ||
1674 | * UBIFS provids 'backing_dev_info' in order to disable readahead. For | ||
1675 | * UBIFS, I/O is not deferred, it is done immediately in readpage, | ||
1676 | * which means the user would have to wait not just for their own I/O | ||
1677 | * but the readahead I/O as well i.e. completely pointless. | ||
1678 | * | ||
1679 | * Read-ahead will be disabled because @c->bdi.ra_pages is 0. | ||
1680 | */ | ||
1681 | c->bdi.capabilities = BDI_CAP_MAP_COPY; | ||
1682 | c->bdi.unplug_io_fn = default_unplug_io_fn; | ||
1683 | err = bdi_init(&c->bdi); | ||
1684 | if (err) | ||
1685 | goto out_close; | ||
1686 | |||
1687 | err = ubifs_parse_options(c, data, 0); | ||
1688 | if (err) | ||
1689 | goto out_bdi; | ||
1690 | |||
1691 | c->vfs_sb = sb; | ||
1692 | |||
1693 | sb->s_fs_info = c; | ||
1694 | sb->s_magic = UBIFS_SUPER_MAGIC; | ||
1695 | sb->s_blocksize = UBIFS_BLOCK_SIZE; | ||
1696 | sb->s_blocksize_bits = UBIFS_BLOCK_SHIFT; | ||
1697 | sb->s_dev = c->vi.cdev; | ||
1698 | sb->s_maxbytes = c->max_inode_sz = key_max_inode_size(c); | ||
1699 | if (c->max_inode_sz > MAX_LFS_FILESIZE) | ||
1700 | sb->s_maxbytes = c->max_inode_sz = MAX_LFS_FILESIZE; | ||
1701 | sb->s_op = &ubifs_super_operations; | ||
1702 | |||
1703 | mutex_lock(&c->umount_mutex); | ||
1704 | err = mount_ubifs(c); | ||
1705 | if (err) { | ||
1706 | ubifs_assert(err < 0); | ||
1707 | goto out_unlock; | ||
1708 | } | ||
1709 | |||
1710 | /* Read the root inode */ | ||
1711 | root = ubifs_iget(sb, UBIFS_ROOT_INO); | ||
1712 | if (IS_ERR(root)) { | ||
1713 | err = PTR_ERR(root); | ||
1714 | goto out_umount; | ||
1715 | } | ||
1716 | |||
1717 | sb->s_root = d_alloc_root(root); | ||
1718 | if (!sb->s_root) | ||
1719 | goto out_iput; | ||
1720 | |||
1721 | mutex_unlock(&c->umount_mutex); | ||
1722 | |||
1723 | return 0; | ||
1724 | |||
1725 | out_iput: | ||
1726 | iput(root); | ||
1727 | out_umount: | ||
1728 | ubifs_umount(c); | ||
1729 | out_unlock: | ||
1730 | mutex_unlock(&c->umount_mutex); | ||
1731 | out_bdi: | ||
1732 | bdi_destroy(&c->bdi); | ||
1733 | out_close: | ||
1734 | ubi_close_volume(c->ubi); | ||
1735 | out_free: | ||
1736 | kfree(c); | ||
1737 | return err; | ||
1738 | } | ||
1739 | |||
1740 | static int sb_test(struct super_block *sb, void *data) | ||
1741 | { | ||
1742 | dev_t *dev = data; | ||
1743 | |||
1744 | return sb->s_dev == *dev; | ||
1745 | } | ||
1746 | |||
1747 | static int sb_set(struct super_block *sb, void *data) | ||
1748 | { | ||
1749 | dev_t *dev = data; | ||
1750 | |||
1751 | sb->s_dev = *dev; | ||
1752 | return 0; | ||
1753 | } | ||
1754 | |||
1755 | static int ubifs_get_sb(struct file_system_type *fs_type, int flags, | ||
1756 | const char *name, void *data, struct vfsmount *mnt) | ||
1757 | { | ||
1758 | struct ubi_volume_desc *ubi; | ||
1759 | struct ubi_volume_info vi; | ||
1760 | struct super_block *sb; | ||
1761 | int err; | ||
1762 | |||
1763 | dbg_gen("name %s, flags %#x", name, flags); | ||
1764 | |||
1765 | /* | ||
1766 | * Get UBI device number and volume ID. Mount it read-only so far | ||
1767 | * because this might be a new mount point, and UBI allows only one | ||
1768 | * read-write user at a time. | ||
1769 | */ | ||
1770 | ubi = open_ubi(name, UBI_READONLY); | ||
1771 | if (IS_ERR(ubi)) { | ||
1772 | ubifs_err("cannot open \"%s\", error %d", | ||
1773 | name, (int)PTR_ERR(ubi)); | ||
1774 | return PTR_ERR(ubi); | ||
1775 | } | ||
1776 | ubi_get_volume_info(ubi, &vi); | ||
1777 | |||
1778 | dbg_gen("opened ubi%d_%d", vi.ubi_num, vi.vol_id); | ||
1779 | |||
1780 | sb = sget(fs_type, &sb_test, &sb_set, &vi.cdev); | ||
1781 | if (IS_ERR(sb)) { | ||
1782 | err = PTR_ERR(sb); | ||
1783 | goto out_close; | ||
1784 | } | ||
1785 | |||
1786 | if (sb->s_root) { | ||
1787 | /* A new mount point for already mounted UBIFS */ | ||
1788 | dbg_gen("this ubi volume is already mounted"); | ||
1789 | if ((flags ^ sb->s_flags) & MS_RDONLY) { | ||
1790 | err = -EBUSY; | ||
1791 | goto out_deact; | ||
1792 | } | ||
1793 | } else { | ||
1794 | sb->s_flags = flags; | ||
1795 | /* | ||
1796 | * Pass 'ubi' to 'fill_super()' in sb->s_fs_info where it is | ||
1797 | * replaced by 'c'. | ||
1798 | */ | ||
1799 | sb->s_fs_info = ubi; | ||
1800 | err = ubifs_fill_super(sb, data, flags & MS_SILENT ? 1 : 0); | ||
1801 | if (err) | ||
1802 | goto out_deact; | ||
1803 | /* We do not support atime */ | ||
1804 | sb->s_flags |= MS_ACTIVE | MS_NOATIME; | ||
1805 | } | ||
1806 | |||
1807 | /* 'fill_super()' opens ubi again so we must close it here */ | ||
1808 | ubi_close_volume(ubi); | ||
1809 | |||
1810 | return simple_set_mnt(mnt, sb); | ||
1811 | |||
1812 | out_deact: | ||
1813 | up_write(&sb->s_umount); | ||
1814 | deactivate_super(sb); | ||
1815 | out_close: | ||
1816 | ubi_close_volume(ubi); | ||
1817 | return err; | ||
1818 | } | ||
1819 | |||
1820 | static void ubifs_kill_sb(struct super_block *sb) | ||
1821 | { | ||
1822 | struct ubifs_info *c = sb->s_fs_info; | ||
1823 | |||
1824 | /* | ||
1825 | * We do 'commit_on_unmount()' here instead of 'ubifs_put_super()' | ||
1826 | * in order to be outside BKL. | ||
1827 | */ | ||
1828 | if (sb->s_root && !(sb->s_flags & MS_RDONLY)) | ||
1829 | commit_on_unmount(c); | ||
1830 | /* The un-mount routine is actually done in put_super() */ | ||
1831 | generic_shutdown_super(sb); | ||
1832 | } | ||
1833 | |||
1834 | static struct file_system_type ubifs_fs_type = { | ||
1835 | .name = "ubifs", | ||
1836 | .owner = THIS_MODULE, | ||
1837 | .get_sb = ubifs_get_sb, | ||
1838 | .kill_sb = ubifs_kill_sb | ||
1839 | }; | ||
1840 | |||
1841 | /* | ||
1842 | * Inode slab cache constructor. | ||
1843 | */ | ||
1844 | static void inode_slab_ctor(struct kmem_cache *cachep, void *obj) | ||
1845 | { | ||
1846 | struct ubifs_inode *ui = obj; | ||
1847 | inode_init_once(&ui->vfs_inode); | ||
1848 | } | ||
1849 | |||
1850 | static int __init ubifs_init(void) | ||
1851 | { | ||
1852 | int err; | ||
1853 | |||
1854 | BUILD_BUG_ON(sizeof(struct ubifs_ch) != 24); | ||
1855 | |||
1856 | /* Make sure node sizes are 8-byte aligned */ | ||
1857 | BUILD_BUG_ON(UBIFS_CH_SZ & 7); | ||
1858 | BUILD_BUG_ON(UBIFS_INO_NODE_SZ & 7); | ||
1859 | BUILD_BUG_ON(UBIFS_DENT_NODE_SZ & 7); | ||
1860 | BUILD_BUG_ON(UBIFS_XENT_NODE_SZ & 7); | ||
1861 | BUILD_BUG_ON(UBIFS_DATA_NODE_SZ & 7); | ||
1862 | BUILD_BUG_ON(UBIFS_TRUN_NODE_SZ & 7); | ||
1863 | BUILD_BUG_ON(UBIFS_SB_NODE_SZ & 7); | ||
1864 | BUILD_BUG_ON(UBIFS_MST_NODE_SZ & 7); | ||
1865 | BUILD_BUG_ON(UBIFS_REF_NODE_SZ & 7); | ||
1866 | BUILD_BUG_ON(UBIFS_CS_NODE_SZ & 7); | ||
1867 | BUILD_BUG_ON(UBIFS_ORPH_NODE_SZ & 7); | ||
1868 | |||
1869 | BUILD_BUG_ON(UBIFS_MAX_DENT_NODE_SZ & 7); | ||
1870 | BUILD_BUG_ON(UBIFS_MAX_XENT_NODE_SZ & 7); | ||
1871 | BUILD_BUG_ON(UBIFS_MAX_DATA_NODE_SZ & 7); | ||
1872 | BUILD_BUG_ON(UBIFS_MAX_INO_NODE_SZ & 7); | ||
1873 | BUILD_BUG_ON(UBIFS_MAX_NODE_SZ & 7); | ||
1874 | BUILD_BUG_ON(MIN_WRITE_SZ & 7); | ||
1875 | |||
1876 | /* Check min. node size */ | ||
1877 | BUILD_BUG_ON(UBIFS_INO_NODE_SZ < MIN_WRITE_SZ); | ||
1878 | BUILD_BUG_ON(UBIFS_DENT_NODE_SZ < MIN_WRITE_SZ); | ||
1879 | BUILD_BUG_ON(UBIFS_XENT_NODE_SZ < MIN_WRITE_SZ); | ||
1880 | BUILD_BUG_ON(UBIFS_TRUN_NODE_SZ < MIN_WRITE_SZ); | ||
1881 | |||
1882 | BUILD_BUG_ON(UBIFS_MAX_DENT_NODE_SZ > UBIFS_MAX_NODE_SZ); | ||
1883 | BUILD_BUG_ON(UBIFS_MAX_XENT_NODE_SZ > UBIFS_MAX_NODE_SZ); | ||
1884 | BUILD_BUG_ON(UBIFS_MAX_DATA_NODE_SZ > UBIFS_MAX_NODE_SZ); | ||
1885 | BUILD_BUG_ON(UBIFS_MAX_INO_NODE_SZ > UBIFS_MAX_NODE_SZ); | ||
1886 | |||
1887 | /* Defined node sizes */ | ||
1888 | BUILD_BUG_ON(UBIFS_SB_NODE_SZ != 4096); | ||
1889 | BUILD_BUG_ON(UBIFS_MST_NODE_SZ != 512); | ||
1890 | BUILD_BUG_ON(UBIFS_INO_NODE_SZ != 160); | ||
1891 | BUILD_BUG_ON(UBIFS_REF_NODE_SZ != 64); | ||
1892 | |||
1893 | /* | ||
1894 | * We require that PAGE_CACHE_SIZE is greater-than-or-equal-to | ||
1895 | * UBIFS_BLOCK_SIZE. It is assumed that both are powers of 2. | ||
1896 | */ | ||
1897 | if (PAGE_CACHE_SIZE < UBIFS_BLOCK_SIZE) { | ||
1898 | ubifs_err("VFS page cache size is %u bytes, but UBIFS requires" | ||
1899 | " at least 4096 bytes", | ||
1900 | (unsigned int)PAGE_CACHE_SIZE); | ||
1901 | return -EINVAL; | ||
1902 | } | ||
1903 | |||
1904 | err = register_filesystem(&ubifs_fs_type); | ||
1905 | if (err) { | ||
1906 | ubifs_err("cannot register file system, error %d", err); | ||
1907 | return err; | ||
1908 | } | ||
1909 | |||
1910 | err = -ENOMEM; | ||
1911 | ubifs_inode_slab = kmem_cache_create("ubifs_inode_slab", | ||
1912 | sizeof(struct ubifs_inode), 0, | ||
1913 | SLAB_MEM_SPREAD | SLAB_RECLAIM_ACCOUNT, | ||
1914 | &inode_slab_ctor); | ||
1915 | if (!ubifs_inode_slab) | ||
1916 | goto out_reg; | ||
1917 | |||
1918 | register_shrinker(&ubifs_shrinker_info); | ||
1919 | |||
1920 | err = ubifs_compressors_init(); | ||
1921 | if (err) | ||
1922 | goto out_compr; | ||
1923 | |||
1924 | return 0; | ||
1925 | |||
1926 | out_compr: | ||
1927 | unregister_shrinker(&ubifs_shrinker_info); | ||
1928 | kmem_cache_destroy(ubifs_inode_slab); | ||
1929 | out_reg: | ||
1930 | unregister_filesystem(&ubifs_fs_type); | ||
1931 | return err; | ||
1932 | } | ||
1933 | /* late_initcall to let compressors initialize first */ | ||
1934 | late_initcall(ubifs_init); | ||
1935 | |||
1936 | static void __exit ubifs_exit(void) | ||
1937 | { | ||
1938 | ubifs_assert(list_empty(&ubifs_infos)); | ||
1939 | ubifs_assert(atomic_long_read(&ubifs_clean_zn_cnt) == 0); | ||
1940 | |||
1941 | ubifs_compressors_exit(); | ||
1942 | unregister_shrinker(&ubifs_shrinker_info); | ||
1943 | kmem_cache_destroy(ubifs_inode_slab); | ||
1944 | unregister_filesystem(&ubifs_fs_type); | ||
1945 | } | ||
1946 | module_exit(ubifs_exit); | ||
1947 | |||
1948 | MODULE_LICENSE("GPL"); | ||
1949 | MODULE_VERSION(__stringify(UBIFS_VERSION)); | ||
1950 | MODULE_AUTHOR("Artem Bityutskiy, Adrian Hunter"); | ||
1951 | MODULE_DESCRIPTION("UBIFS - UBI File System"); | ||