Blame view
fs/ubifs/replay.c
29.2 KB
1e51764a3 UBIFS: add new fl... |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
/* * This file is part of UBIFS. * * Copyright (C) 2006-2008 Nokia Corporation. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 as published by * the Free Software Foundation. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for * more details. * * You should have received a copy of the GNU General Public License along with * this program; if not, write to the Free Software Foundation, Inc., 51 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * * Authors: Adrian Hunter * Artem Bityutskiy (Битюцкий Артём) */ /* * This file contains journal replay code. It runs when the file-system is being * mounted and requires no locking. * * The larger is the journal, the longer it takes to scan it, so the longer it * takes to mount UBIFS. This is why the journal has limited size which may be * changed depending on the system requirements. But a larger journal gives * faster I/O speed because it writes the index less frequently. So this is a * trade-off. Also, the journal is indexed by the in-memory index (TNC), so the * larger is the journal, the more memory its index may consume. */ #include "ubifs.h" |
debf12d54 UBIFS: substitute... |
36 |
#include <linux/list_sort.h> |
1e51764a3 UBIFS: add new fl... |
37 |
|
1e51764a3 UBIFS: add new fl... |
38 |
/** |
debf12d54 UBIFS: substitute... |
39 |
* struct replay_entry - replay list entry. |
1e51764a3 UBIFS: add new fl... |
40 41 42 |
* @lnum: logical eraseblock number of the node * @offs: node offset * @len: node length |
074bcb9b5 UBIFS: simplify r... |
43 |
* @deletion: non-zero if this entry corresponds to a node deletion |
1e51764a3 UBIFS: add new fl... |
44 |
* @sqnum: node sequence number |
debf12d54 UBIFS: substitute... |
45 |
* @list: links the replay list |
1e51764a3 UBIFS: add new fl... |
46 47 48 49 |
* @key: node key * @nm: directory entry name * @old_size: truncation old size * @new_size: truncation new size |
1e51764a3 UBIFS: add new fl... |
50 |
* |
debf12d54 UBIFS: substitute... |
51 52 53 |
* The replay process first scans all buds and builds the replay list, then * sorts the replay list in nodes sequence number order, and then inserts all * the replay entries to the TNC. |
1e51764a3 UBIFS: add new fl... |
54 55 56 57 58 |
*/ struct replay_entry { int lnum; int offs; int len; |
074bcb9b5 UBIFS: simplify r... |
59 |
unsigned int deletion:1; |
1e51764a3 UBIFS: add new fl... |
60 |
unsigned long long sqnum; |
debf12d54 UBIFS: substitute... |
61 |
struct list_head list; |
1e51764a3 UBIFS: add new fl... |
62 63 64 65 66 67 68 |
union ubifs_key key; union { struct qstr nm; struct { loff_t old_size; loff_t new_size; }; |
1e51764a3 UBIFS: add new fl... |
69 70 71 72 73 74 75 |
}; }; /** * struct bud_entry - entry in the list of buds to replay. * @list: next bud in the list * @bud: bud description object |
1e51764a3 UBIFS: add new fl... |
76 |
* @sqnum: reference node sequence number |
af1dd4126 UBIFS: store free... |
77 78 |
* @free: free bytes in the bud * @dirty: dirty bytes in the bud |
1e51764a3 UBIFS: add new fl... |
79 80 81 82 |
*/ struct bud_entry { struct list_head list; struct ubifs_bud *bud; |
1e51764a3 UBIFS: add new fl... |
83 |
unsigned long long sqnum; |
af1dd4126 UBIFS: store free... |
84 85 |
int free; int dirty; |
1e51764a3 UBIFS: add new fl... |
86 87 88 89 90 |
}; /** * set_bud_lprops - set free and dirty space used by a bud. * @c: UBIFS file-system description object |
074bcb9b5 UBIFS: simplify r... |
91 92 93 94 95 |
* @b: bud entry which describes the bud * * This function makes sure the LEB properties of bud @b are set correctly * after the replay. Returns zero in case of success and a negative error code * in case of failure. |
1e51764a3 UBIFS: add new fl... |
96 |
*/ |
074bcb9b5 UBIFS: simplify r... |
97 |
static int set_bud_lprops(struct ubifs_info *c, struct bud_entry *b) |
1e51764a3 UBIFS: add new fl... |
98 99 100 101 102 |
{ const struct ubifs_lprops *lp; int err = 0, dirty; ubifs_get_lprops(c); |
074bcb9b5 UBIFS: simplify r... |
103 |
lp = ubifs_lpt_lookup_dirty(c, b->bud->lnum); |
1e51764a3 UBIFS: add new fl... |
104 105 106 107 108 109 |
if (IS_ERR(lp)) { err = PTR_ERR(lp); goto out; } dirty = lp->dirty; |
074bcb9b5 UBIFS: simplify r... |
110 |
if (b->bud->start == 0 && (lp->free != c->leb_size || lp->dirty != 0)) { |
1e51764a3 UBIFS: add new fl... |
111 112 113 |
/* * The LEB was added to the journal with a starting offset of * zero which means the LEB must have been empty. The LEB |
074bcb9b5 UBIFS: simplify r... |
114 115 |
* property values should be @lp->free == @c->leb_size and * @lp->dirty == 0, but that is not the case. The reason is that |
7a9c3e399 UBIFS: improve co... |
116 117 118 119 120 |
* the LEB had been garbage collected before it became the bud, * and there was not commit inbetween. The garbage collector * resets the free and dirty space without recording it * anywhere except lprops, so if there was no commit then * lprops does not have that information. |
1e51764a3 UBIFS: add new fl... |
121 122 123 |
* * We do not need to adjust free space because the scan has told * us the exact value which is recorded in the replay entry as |
074bcb9b5 UBIFS: simplify r... |
124 |
* @b->free. |
1e51764a3 UBIFS: add new fl... |
125 126 127 128 129 |
* * However we do need to subtract from the dirty space the * amount of space that the garbage collector reclaimed, which * is the whole LEB minus the amount of space that was free. */ |
074bcb9b5 UBIFS: simplify r... |
130 |
dbg_mnt("bud LEB %d was GC'd (%d free, %d dirty)", b->bud->lnum, |
1e51764a3 UBIFS: add new fl... |
131 |
lp->free, lp->dirty); |
074bcb9b5 UBIFS: simplify r... |
132 |
dbg_gc("bud LEB %d was GC'd (%d free, %d dirty)", b->bud->lnum, |
1e51764a3 UBIFS: add new fl... |
133 134 135 136 |
lp->free, lp->dirty); dirty -= c->leb_size - lp->free; /* * If the replay order was perfect the dirty space would now be |
7d4e9ccb4 UBIFS: fix commen... |
137 |
* zero. The order is not perfect because the journal heads |
6edbfafda UBIFS: restore bu... |
138 |
* race with each other. This is not a problem but is does mean |
1e51764a3 UBIFS: add new fl... |
139 140 141 142 143 |
* that the dirty space may temporarily exceed c->leb_size * during the replay. */ if (dirty != 0) dbg_msg("LEB %d lp: %d free %d dirty " |
074bcb9b5 UBIFS: simplify r... |
144 145 |
"replay: %d free %d dirty", b->bud->lnum, lp->free, lp->dirty, b->free, b->dirty); |
1e51764a3 UBIFS: add new fl... |
146 |
} |
074bcb9b5 UBIFS: simplify r... |
147 |
lp = ubifs_change_lp(c, lp, b->free, dirty + b->dirty, |
1e51764a3 UBIFS: add new fl... |
148 149 150 151 152 |
lp->flags | LPROPS_TAKEN, 0); if (IS_ERR(lp)) { err = PTR_ERR(lp); goto out; } |
52c6e6f99 UBIFS: seek journ... |
153 154 |
/* Make sure the journal head points to the latest bud */ |
074bcb9b5 UBIFS: simplify r... |
155 156 157 |
err = ubifs_wbuf_seek_nolock(&c->jheads[b->bud->jhead].wbuf, b->bud->lnum, c->leb_size - b->free, UBI_SHORTTERM); |
52c6e6f99 UBIFS: seek journ... |
158 |
|
1e51764a3 UBIFS: add new fl... |
159 160 161 162 163 164 |
out: ubifs_release_lprops(c); return err; } /** |
074bcb9b5 UBIFS: simplify r... |
165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 |
* set_buds_lprops - set free and dirty space for all replayed buds. * @c: UBIFS file-system description object * * This function sets LEB properties for all replayed buds. Returns zero in * case of success and a negative error code in case of failure. */ static int set_buds_lprops(struct ubifs_info *c) { struct bud_entry *b; int err; list_for_each_entry(b, &c->replay_buds, list) { err = set_bud_lprops(c, b); if (err) return err; } return 0; } /** |
1e51764a3 UBIFS: add new fl... |
186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 |
* trun_remove_range - apply a replay entry for a truncation to the TNC. * @c: UBIFS file-system description object * @r: replay entry of truncation */ static int trun_remove_range(struct ubifs_info *c, struct replay_entry *r) { unsigned min_blk, max_blk; union ubifs_key min_key, max_key; ino_t ino; min_blk = r->new_size / UBIFS_BLOCK_SIZE; if (r->new_size & (UBIFS_BLOCK_SIZE - 1)) min_blk += 1; max_blk = r->old_size / UBIFS_BLOCK_SIZE; if ((r->old_size & (UBIFS_BLOCK_SIZE - 1)) == 0) max_blk -= 1; ino = key_inum(c, &r->key); data_key_init(c, &min_key, ino, min_blk); data_key_init(c, &max_key, ino, max_blk); return ubifs_tnc_remove_range(c, &min_key, &max_key); } /** * apply_replay_entry - apply a replay entry to the TNC. * @c: UBIFS file-system description object * @r: replay entry to apply * * Apply a replay entry to the TNC. */ static int apply_replay_entry(struct ubifs_info *c, struct replay_entry *r) { |
074bcb9b5 UBIFS: simplify r... |
221 |
int err; |
1e51764a3 UBIFS: add new fl... |
222 |
|
515315a12 UBIFS: fix key pr... |
223 224 |
dbg_mntk(&r->key, "LEB %d:%d len %d deletion %d sqnum %llu key ", r->lnum, r->offs, r->len, r->deletion, r->sqnum); |
1e51764a3 UBIFS: add new fl... |
225 226 227 |
/* Set c->replay_sqnum to help deal with dangling branches. */ c->replay_sqnum = r->sqnum; |
074bcb9b5 UBIFS: simplify r... |
228 229 |
if (is_hash_key(c, &r->key)) { if (r->deletion) |
1e51764a3 UBIFS: add new fl... |
230 231 232 233 234 |
err = ubifs_tnc_remove_nm(c, &r->key, &r->nm); else err = ubifs_tnc_add_nm(c, &r->key, r->lnum, r->offs, r->len, &r->nm); } else { |
074bcb9b5 UBIFS: simplify r... |
235 |
if (r->deletion) |
1e51764a3 UBIFS: add new fl... |
236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 |
switch (key_type(c, &r->key)) { case UBIFS_INO_KEY: { ino_t inum = key_inum(c, &r->key); err = ubifs_tnc_remove_ino(c, inum); break; } case UBIFS_TRUN_KEY: err = trun_remove_range(c, r); break; default: err = ubifs_tnc_remove(c, &r->key); break; } else err = ubifs_tnc_add(c, &r->key, r->lnum, r->offs, r->len); if (err) return err; if (c->need_recovery) |
074bcb9b5 UBIFS: simplify r... |
258 |
err = ubifs_recover_size_accum(c, &r->key, r->deletion, |
1e51764a3 UBIFS: add new fl... |
259 260 261 262 263 264 265 |
r->new_size); } return err; } /** |
debf12d54 UBIFS: substitute... |
266 267 268 269 |
* replay_entries_cmp - compare 2 replay entries. * @priv: UBIFS file-system description object * @a: first replay entry * @a: second replay entry |
1e51764a3 UBIFS: add new fl... |
270 |
* |
debf12d54 UBIFS: substitute... |
271 272 273 |
* This is a comparios function for 'list_sort()' which compares 2 replay * entries @a and @b by comparing their sequence numer. Returns %1 if @a has * greater sequence number and %-1 otherwise. |
1e51764a3 UBIFS: add new fl... |
274 |
*/ |
debf12d54 UBIFS: substitute... |
275 276 |
static int replay_entries_cmp(void *priv, struct list_head *a, struct list_head *b) |
1e51764a3 UBIFS: add new fl... |
277 |
{ |
debf12d54 UBIFS: substitute... |
278 279 280 281 282 283 284 285 286 287 288 289 |
struct replay_entry *ra, *rb; cond_resched(); if (a == b) return 0; ra = list_entry(a, struct replay_entry, list); rb = list_entry(b, struct replay_entry, list); ubifs_assert(ra->sqnum != rb->sqnum); if (ra->sqnum > rb->sqnum) return 1; return -1; |
1e51764a3 UBIFS: add new fl... |
290 291 292 |
} /** |
debf12d54 UBIFS: substitute... |
293 |
* apply_replay_list - apply the replay list to the TNC. |
1e51764a3 UBIFS: add new fl... |
294 295 |
* @c: UBIFS file-system description object * |
debf12d54 UBIFS: substitute... |
296 297 |
* Apply all entries in the replay list to the TNC. Returns zero in case of * success and a negative error code in case of failure. |
1e51764a3 UBIFS: add new fl... |
298 |
*/ |
debf12d54 UBIFS: substitute... |
299 |
static int apply_replay_list(struct ubifs_info *c) |
1e51764a3 UBIFS: add new fl... |
300 |
{ |
debf12d54 UBIFS: substitute... |
301 302 |
struct replay_entry *r; int err; |
1e51764a3 UBIFS: add new fl... |
303 |
|
debf12d54 UBIFS: substitute... |
304 |
list_sort(c, &c->replay_list, &replay_entries_cmp); |
1e51764a3 UBIFS: add new fl... |
305 |
|
debf12d54 UBIFS: substitute... |
306 |
list_for_each_entry(r, &c->replay_list, list) { |
1e51764a3 UBIFS: add new fl... |
307 |
cond_resched(); |
1e51764a3 UBIFS: add new fl... |
308 309 310 |
err = apply_replay_entry(c, r); if (err) return err; |
1e51764a3 UBIFS: add new fl... |
311 |
} |
debf12d54 UBIFS: substitute... |
312 |
|
1e51764a3 UBIFS: add new fl... |
313 314 315 316 |
return 0; } /** |
debf12d54 UBIFS: substitute... |
317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 |
* destroy_replay_list - destroy the replay. * @c: UBIFS file-system description object * * Destroy the replay list. */ static void destroy_replay_list(struct ubifs_info *c) { struct replay_entry *r, *tmp; list_for_each_entry_safe(r, tmp, &c->replay_list, list) { if (is_hash_key(c, &r->key)) kfree(r->nm.name); list_del(&r->list); kfree(r); } } /** * insert_node - insert a node to the replay list |
1e51764a3 UBIFS: add new fl... |
336 337 338 339 340 341 342 343 344 345 346 |
* @c: UBIFS file-system description object * @lnum: node logical eraseblock number * @offs: node offset * @len: node length * @key: node key * @sqnum: sequence number * @deletion: non-zero if this is a deletion * @used: number of bytes in use in a LEB * @old_size: truncation old size * @new_size: truncation new size * |
debf12d54 UBIFS: substitute... |
347 348 349 350 351 352 |
* This function inserts a scanned non-direntry node to the replay list. The * replay list contains @struct replay_entry elements, and we sort this list in * sequence number order before applying it. The replay list is applied at the * very end of the replay process. Since the list is sorted in sequence number * order, the older modifications are applied first. This function returns zero * in case of success and a negative error code in case of failure. |
1e51764a3 UBIFS: add new fl... |
353 354 355 356 357 358 |
*/ static int insert_node(struct ubifs_info *c, int lnum, int offs, int len, union ubifs_key *key, unsigned long long sqnum, int deletion, int *used, loff_t old_size, loff_t new_size) { |
1e51764a3 UBIFS: add new fl... |
359 |
struct replay_entry *r; |
515315a12 UBIFS: fix key pr... |
360 |
dbg_mntk(key, "add LEB %d:%d, key ", lnum, offs); |
debf12d54 UBIFS: substitute... |
361 |
|
1e51764a3 UBIFS: add new fl... |
362 363 |
if (key_inum(c, key) >= c->highest_inum) c->highest_inum = key_inum(c, key); |
1e51764a3 UBIFS: add new fl... |
364 365 366 367 368 369 370 371 372 |
r = kzalloc(sizeof(struct replay_entry), GFP_KERNEL); if (!r) return -ENOMEM; if (!deletion) *used += ALIGN(len, 8); r->lnum = lnum; r->offs = offs; r->len = len; |
074bcb9b5 UBIFS: simplify r... |
373 |
r->deletion = !!deletion; |
1e51764a3 UBIFS: add new fl... |
374 |
r->sqnum = sqnum; |
074bcb9b5 UBIFS: simplify r... |
375 |
key_copy(c, key, &r->key); |
1e51764a3 UBIFS: add new fl... |
376 377 |
r->old_size = old_size; r->new_size = new_size; |
1e51764a3 UBIFS: add new fl... |
378 |
|
debf12d54 UBIFS: substitute... |
379 |
list_add_tail(&r->list, &c->replay_list); |
1e51764a3 UBIFS: add new fl... |
380 381 382 383 |
return 0; } /** |
debf12d54 UBIFS: substitute... |
384 |
* insert_dent - insert a directory entry node into the replay list. |
1e51764a3 UBIFS: add new fl... |
385 386 387 388 389 390 391 392 393 394 395 |
* @c: UBIFS file-system description object * @lnum: node logical eraseblock number * @offs: node offset * @len: node length * @key: node key * @name: directory entry name * @nlen: directory entry name length * @sqnum: sequence number * @deletion: non-zero if this is a deletion * @used: number of bytes in use in a LEB * |
debf12d54 UBIFS: substitute... |
396 397 398 |
* This function inserts a scanned directory entry node or an extended * attribute entry to the replay list. Returns zero in case of success and a * negative error code in case of failure. |
1e51764a3 UBIFS: add new fl... |
399 400 401 402 403 |
*/ static int insert_dent(struct ubifs_info *c, int lnum, int offs, int len, union ubifs_key *key, const char *name, int nlen, unsigned long long sqnum, int deletion, int *used) { |
1e51764a3 UBIFS: add new fl... |
404 405 |
struct replay_entry *r; char *nbuf; |
515315a12 UBIFS: fix key pr... |
406 |
dbg_mntk(key, "add LEB %d:%d, key ", lnum, offs); |
1e51764a3 UBIFS: add new fl... |
407 408 |
if (key_inum(c, key) >= c->highest_inum) c->highest_inum = key_inum(c, key); |
1e51764a3 UBIFS: add new fl... |
409 410 411 |
r = kzalloc(sizeof(struct replay_entry), GFP_KERNEL); if (!r) return -ENOMEM; |
debf12d54 UBIFS: substitute... |
412 |
|
1e51764a3 UBIFS: add new fl... |
413 414 415 416 417 418 419 420 421 422 423 |
nbuf = kmalloc(nlen + 1, GFP_KERNEL); if (!nbuf) { kfree(r); return -ENOMEM; } if (!deletion) *used += ALIGN(len, 8); r->lnum = lnum; r->offs = offs; r->len = len; |
074bcb9b5 UBIFS: simplify r... |
424 |
r->deletion = !!deletion; |
1e51764a3 UBIFS: add new fl... |
425 |
r->sqnum = sqnum; |
074bcb9b5 UBIFS: simplify r... |
426 |
key_copy(c, key, &r->key); |
1e51764a3 UBIFS: add new fl... |
427 428 429 430 |
r->nm.len = nlen; memcpy(nbuf, name, nlen); nbuf[nlen] = '\0'; r->nm.name = nbuf; |
1e51764a3 UBIFS: add new fl... |
431 |
|
debf12d54 UBIFS: substitute... |
432 |
list_add_tail(&r->list, &c->replay_list); |
1e51764a3 UBIFS: add new fl... |
433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 |
return 0; } /** * ubifs_validate_entry - validate directory or extended attribute entry node. * @c: UBIFS file-system description object * @dent: the node to validate * * This function validates directory or extended attribute entry node @dent. * Returns zero if the node is all right and a %-EINVAL if not. */ int ubifs_validate_entry(struct ubifs_info *c, const struct ubifs_dent_node *dent) { int key_type = key_type_flash(c, dent->key); int nlen = le16_to_cpu(dent->nlen); if (le32_to_cpu(dent->ch.len) != nlen + UBIFS_DENT_NODE_SZ + 1 || dent->type >= UBIFS_ITYPES_CNT || nlen > UBIFS_MAX_NLEN || dent->name[nlen] != 0 || strnlen(dent->name, nlen) != nlen || le64_to_cpu(dent->inum) > MAX_INUM) { ubifs_err("bad %s node", key_type == UBIFS_DENT_KEY ? "directory entry" : "extended attribute entry"); return -EINVAL; } if (key_type != UBIFS_DENT_KEY && key_type != UBIFS_XENT_KEY) { ubifs_err("bad key type %d", key_type); return -EINVAL; } return 0; } /** |
91c66083f UBIFS: expect cor... |
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 |
* is_last_bud - check if the bud is the last in the journal head. * @c: UBIFS file-system description object * @bud: bud description object * * This function checks if bud @bud is the last bud in its journal head. This * information is then used by 'replay_bud()' to decide whether the bud can * have corruptions or not. Indeed, only last buds can be corrupted by power * cuts. Returns %1 if this is the last bud, and %0 if not. */ static int is_last_bud(struct ubifs_info *c, struct ubifs_bud *bud) { struct ubifs_jhead *jh = &c->jheads[bud->jhead]; struct ubifs_bud *next; uint32_t data; int err; if (list_is_last(&bud->list, &jh->buds_list)) return 1; /* * The following is a quirk to make sure we work correctly with UBIFS * images used with older UBIFS. * * Normally, the last bud will be the last in the journal head's list * of bud. However, there is one exception if the UBIFS image belongs * to older UBIFS. This is fairly unlikely: one would need to use old * UBIFS, then have a power cut exactly at the right point, and then * try to mount this image with new UBIFS. * * The exception is: it is possible to have 2 buds A and B, A goes * before B, and B is the last, bud B is contains no data, and bud A is * corrupted at the end. The reason is that in older versions when the * journal code switched the next bud (from A to B), it first added a * log reference node for the new bud (B), and only after this it * synchronized the write-buffer of current bud (A). But later this was * changed and UBIFS started to always synchronize the write-buffer of * the bud (A) before writing the log reference for the new bud (B). * * But because older UBIFS always synchronized A's write-buffer before * writing to B, we can recognize this exceptional situation but * checking the contents of bud B - if it is empty, then A can be * treated as the last and we can recover it. * * TODO: remove this piece of code in a couple of years (today it is * 16.05.2011). */ next = list_entry(bud->list.next, struct ubifs_bud, list); if (!list_is_last(&next->list, &jh->buds_list)) return 0; |
d304820a1 UBIFS: switch to ... |
518 |
err = ubifs_leb_read(c, next->lnum, (char *)&data, next->start, 4, 1); |
91c66083f UBIFS: expect cor... |
519 520 521 522 523 524 525 |
if (err) return 0; return data == 0xFFFFFFFF; } /** |
1e51764a3 UBIFS: add new fl... |
526 527 |
* replay_bud - replay a bud logical eraseblock. * @c: UBIFS file-system description object |
e76a45264 UBIFS: change bud... |
528 |
* @b: bud entry which describes the bud |
1e51764a3 UBIFS: add new fl... |
529 |
* |
e76a45264 UBIFS: change bud... |
530 531 532 |
* This function replays bud @bud, recovers it if needed, and adds all nodes * from this bud to the replay list. Returns zero in case of success and a * negative error code in case of failure. |
1e51764a3 UBIFS: add new fl... |
533 |
*/ |
e76a45264 UBIFS: change bud... |
534 |
static int replay_bud(struct ubifs_info *c, struct bud_entry *b) |
1e51764a3 UBIFS: add new fl... |
535 |
{ |
91c66083f UBIFS: expect cor... |
536 |
int is_last = is_last_bud(c, b->bud); |
e76a45264 UBIFS: change bud... |
537 |
int err = 0, used = 0, lnum = b->bud->lnum, offs = b->bud->start; |
1e51764a3 UBIFS: add new fl... |
538 539 |
struct ubifs_scan_leb *sleb; struct ubifs_scan_node *snod; |
1e51764a3 UBIFS: add new fl... |
540 |
|
91c66083f UBIFS: expect cor... |
541 542 |
dbg_mnt("replay bud LEB %d, head %d, offs %d, is_last %d", lnum, b->bud->jhead, offs, is_last); |
e76a45264 UBIFS: change bud... |
543 |
|
91c66083f UBIFS: expect cor... |
544 545 546 547 548 549 550 |
if (c->need_recovery && is_last) /* * Recover only last LEBs in the journal heads, because power * cuts may cause corruptions only in these LEBs, because only * these LEBs could possibly be written to at the power cut * time. */ |
efcfde54c UBIFS: amend ubif... |
551 |
sleb = ubifs_recover_leb(c, lnum, offs, c->sbuf, b->bud->jhead); |
1e51764a3 UBIFS: add new fl... |
552 |
else |
348709bad UBIFS: do not pri... |
553 |
sleb = ubifs_scan(c, lnum, offs, c->sbuf, 0); |
1e51764a3 UBIFS: add new fl... |
554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 |
if (IS_ERR(sleb)) return PTR_ERR(sleb); /* * The bud does not have to start from offset zero - the beginning of * the 'lnum' LEB may contain previously committed data. One of the * things we have to do in replay is to correctly update lprops with * newer information about this LEB. * * At this point lprops thinks that this LEB has 'c->leb_size - offs' * bytes of free space because it only contain information about * committed data. * * But we know that real amount of free space is 'c->leb_size - * sleb->endpt', and the space in the 'lnum' LEB between 'offs' and * 'sleb->endpt' is used by bud data. We have to correctly calculate * how much of these data are dirty and update lprops with this * information. * * The dirt in that LEB region is comprised of padding nodes, deletion * nodes, truncation nodes and nodes which are obsoleted by subsequent * nodes in this LEB. So instead of calculating clean space, we * calculate used space ('used' variable). */ list_for_each_entry(snod, &sleb->nodes, list) { int deletion = 0; cond_resched(); if (snod->sqnum >= SQNUM_WATERMARK) { ubifs_err("file system's life ended"); goto out_dump; } if (snod->sqnum > c->max_sqnum) c->max_sqnum = snod->sqnum; switch (snod->type) { case UBIFS_INO_NODE: { struct ubifs_ino_node *ino = snod->node; loff_t new_size = le64_to_cpu(ino->size); if (le32_to_cpu(ino->nlink) == 0) deletion = 1; err = insert_node(c, lnum, snod->offs, snod->len, &snod->key, snod->sqnum, deletion, &used, 0, new_size); break; } case UBIFS_DATA_NODE: { struct ubifs_data_node *dn = snod->node; loff_t new_size = le32_to_cpu(dn->size) + key_block(c, &snod->key) * UBIFS_BLOCK_SIZE; err = insert_node(c, lnum, snod->offs, snod->len, &snod->key, snod->sqnum, deletion, &used, 0, new_size); break; } case UBIFS_DENT_NODE: case UBIFS_XENT_NODE: { struct ubifs_dent_node *dent = snod->node; err = ubifs_validate_entry(c, dent); if (err) goto out_dump; err = insert_dent(c, lnum, snod->offs, snod->len, &snod->key, dent->name, le16_to_cpu(dent->nlen), snod->sqnum, !le64_to_cpu(dent->inum), &used); break; } case UBIFS_TRUN_NODE: { struct ubifs_trun_node *trun = snod->node; loff_t old_size = le64_to_cpu(trun->old_size); loff_t new_size = le64_to_cpu(trun->new_size); union ubifs_key key; /* Validate truncation node */ if (old_size < 0 || old_size > c->max_inode_sz || new_size < 0 || new_size > c->max_inode_sz || old_size <= new_size) { ubifs_err("bad truncation node"); goto out_dump; } /* * Create a fake truncation key just to use the same * functions which expect nodes to have keys. */ trun_key_init(c, &key, le32_to_cpu(trun->inum)); err = insert_node(c, lnum, snod->offs, snod->len, &key, snod->sqnum, 1, &used, old_size, new_size); break; } default: ubifs_err("unexpected node type %d in bud LEB %d:%d", snod->type, lnum, snod->offs); err = -EINVAL; goto out_dump; } if (err) goto out; } |
c49139d80 UBIFS: remove BUG... |
666 |
ubifs_assert(ubifs_search_bud(c, lnum)); |
1e51764a3 UBIFS: add new fl... |
667 668 |
ubifs_assert(sleb->endpt - offs >= used); ubifs_assert(sleb->endpt % c->min_io_size == 0); |
e76a45264 UBIFS: change bud... |
669 670 671 |
b->dirty = sleb->endpt - offs - used; b->free = c->leb_size - sleb->endpt; dbg_mnt("bud LEB %d replied: dirty %d, free %d", lnum, b->dirty, b->free); |
1e51764a3 UBIFS: add new fl... |
672 673 674 675 676 677 678 679 680 681 682 683 684 |
out: ubifs_scan_destroy(sleb); return err; out_dump: ubifs_err("bad node is at LEB %d:%d", lnum, snod->offs); dbg_dump_node(c, snod->node); ubifs_scan_destroy(sleb); return -EINVAL; } /** |
1e51764a3 UBIFS: add new fl... |
685 686 687 688 689 690 691 692 693 |
* replay_buds - replay all buds. * @c: UBIFS file-system description object * * This function returns zero in case of success and a negative error code in * case of failure. */ static int replay_buds(struct ubifs_info *c) { struct bud_entry *b; |
074bcb9b5 UBIFS: simplify r... |
694 |
int err; |
7703f09de UBIFS: double che... |
695 |
unsigned long long prev_sqnum = 0; |
1e51764a3 UBIFS: add new fl... |
696 697 |
list_for_each_entry(b, &c->replay_buds, list) { |
e76a45264 UBIFS: change bud... |
698 |
err = replay_bud(c, b); |
1e51764a3 UBIFS: add new fl... |
699 700 |
if (err) return err; |
7703f09de UBIFS: double che... |
701 702 703 |
ubifs_assert(b->sqnum > prev_sqnum); prev_sqnum = b->sqnum; |
1e51764a3 UBIFS: add new fl... |
704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 |
} return 0; } /** * destroy_bud_list - destroy the list of buds to replay. * @c: UBIFS file-system description object */ static void destroy_bud_list(struct ubifs_info *c) { struct bud_entry *b; while (!list_empty(&c->replay_buds)) { b = list_entry(c->replay_buds.next, struct bud_entry, list); list_del(&b->list); kfree(b); } } /** * add_replay_bud - add a bud to the list of buds to replay. * @c: UBIFS file-system description object * @lnum: bud logical eraseblock number to replay * @offs: bud start offset * @jhead: journal head to which this bud belongs * @sqnum: reference node sequence number * * This function returns zero in case of success and a negative error code in * case of failure. */ static int add_replay_bud(struct ubifs_info *c, int lnum, int offs, int jhead, unsigned long long sqnum) { struct ubifs_bud *bud; struct bud_entry *b; dbg_mnt("add replay bud LEB %d:%d, head %d", lnum, offs, jhead); bud = kmalloc(sizeof(struct ubifs_bud), GFP_KERNEL); if (!bud) return -ENOMEM; b = kmalloc(sizeof(struct bud_entry), GFP_KERNEL); if (!b) { kfree(bud); return -ENOMEM; } bud->lnum = lnum; bud->start = offs; bud->jhead = jhead; ubifs_add_bud(c, bud); b->bud = bud; b->sqnum = sqnum; list_add_tail(&b->list, &c->replay_buds); return 0; } /** * validate_ref - validate a reference node. * @c: UBIFS file-system description object * @ref: the reference node to validate * @ref_lnum: LEB number of the reference node * @ref_offs: reference node offset * * This function returns %1 if a bud reference already exists for the LEB. %0 is * returned if the reference node is new, otherwise %-EINVAL is returned if * validation failed. */ static int validate_ref(struct ubifs_info *c, const struct ubifs_ref_node *ref) { struct ubifs_bud *bud; int lnum = le32_to_cpu(ref->lnum); unsigned int offs = le32_to_cpu(ref->offs); unsigned int jhead = le32_to_cpu(ref->jhead); /* * ref->offs may point to the end of LEB when the journal head points * to the end of LEB and we write reference node for it during commit. * So this is why we require 'offs > c->leb_size'. */ if (jhead >= c->jhead_cnt || lnum >= c->leb_cnt || lnum < c->main_first || offs > c->leb_size || offs & (c->min_io_size - 1)) return -EINVAL; /* Make sure we have not already looked at this bud */ bud = ubifs_search_bud(c, lnum); if (bud) { if (bud->jhead == jhead && bud->start <= offs) return 1; ubifs_err("bud at LEB %d:%d was already referred", lnum, offs); return -EINVAL; } return 0; } /** * replay_log_leb - replay a log logical eraseblock. * @c: UBIFS file-system description object * @lnum: log logical eraseblock to replay * @offs: offset to start replaying from * @sbuf: scan buffer * * This function replays a log LEB and returns zero in case of success, %1 if * this is the last LEB in the log, and a negative error code in case of * failure. */ static int replay_log_leb(struct ubifs_info *c, int lnum, int offs, void *sbuf) { int err; struct ubifs_scan_leb *sleb; struct ubifs_scan_node *snod; const struct ubifs_cs_node *node; dbg_mnt("replay log LEB %d:%d", lnum, offs); |
348709bad UBIFS: do not pri... |
824 825 |
sleb = ubifs_scan(c, lnum, offs, sbuf, c->need_recovery); if (IS_ERR(sleb)) { |
ed43f2f06 UBIFS: small amen... |
826 827 |
if (PTR_ERR(sleb) != -EUCLEAN || !c->need_recovery) return PTR_ERR(sleb); |
7d08ae3c9 UBIFS: add a comm... |
828 829 830 831 832 |
/* * Note, the below function will recover this log LEB only if * it is the last, because unclean reboots can possibly corrupt * only the tail of the log. */ |
ed43f2f06 UBIFS: small amen... |
833 |
sleb = ubifs_recover_log_leb(c, lnum, offs, sbuf); |
1e51764a3 UBIFS: add new fl... |
834 835 836 837 838 839 840 841 842 843 |
if (IS_ERR(sleb)) return PTR_ERR(sleb); } if (sleb->nodes_cnt == 0) { err = 1; goto out; } node = sleb->buf; |
1e51764a3 UBIFS: add new fl... |
844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 |
snod = list_entry(sleb->nodes.next, struct ubifs_scan_node, list); if (c->cs_sqnum == 0) { /* * This is the first log LEB we are looking at, make sure that * the first node is a commit start node. Also record its * sequence number so that UBIFS can determine where the log * ends, because all nodes which were have higher sequence * numbers. */ if (snod->type != UBIFS_CS_NODE) { dbg_err("first log node at LEB %d:%d is not CS node", lnum, offs); goto out_dump; } if (le64_to_cpu(node->cmt_no) != c->cmt_no) { dbg_err("first CS node at LEB %d:%d has wrong " "commit number %llu expected %llu", lnum, offs, (unsigned long long)le64_to_cpu(node->cmt_no), c->cmt_no); goto out_dump; } c->cs_sqnum = le64_to_cpu(node->ch.sqnum); dbg_mnt("commit start sqnum %llu", c->cs_sqnum); } if (snod->sqnum < c->cs_sqnum) { /* * This means that we reached end of log and now * look to the older log data, which was already * committed but the eraseblock was not erased (UBIFS |
6edbfafda UBIFS: restore bu... |
876 |
* only un-maps it). So this basically means we have to |
1e51764a3 UBIFS: add new fl... |
877 878 879 880 881 882 883 884 885 886 887 888 889 |
* exit with "end of log" code. */ err = 1; goto out; } /* Make sure the first node sits at offset zero of the LEB */ if (snod->offs != 0) { dbg_err("first node is not at zero offset"); goto out_dump; } list_for_each_entry(snod, &sleb->nodes, list) { |
1e51764a3 UBIFS: add new fl... |
890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 |
cond_resched(); if (snod->sqnum >= SQNUM_WATERMARK) { ubifs_err("file system's life ended"); goto out_dump; } if (snod->sqnum < c->cs_sqnum) { dbg_err("bad sqnum %llu, commit sqnum %llu", snod->sqnum, c->cs_sqnum); goto out_dump; } if (snod->sqnum > c->max_sqnum) c->max_sqnum = snod->sqnum; switch (snod->type) { case UBIFS_REF_NODE: { const struct ubifs_ref_node *ref = snod->node; err = validate_ref(c, ref); if (err == 1) break; /* Already have this bud */ if (err) goto out_dump; err = add_replay_bud(c, le32_to_cpu(ref->lnum), le32_to_cpu(ref->offs), le32_to_cpu(ref->jhead), snod->sqnum); if (err) goto out; break; } case UBIFS_CS_NODE: /* Make sure it sits at the beginning of LEB */ if (snod->offs != 0) { ubifs_err("unexpected node in log"); goto out_dump; } break; default: ubifs_err("unexpected node in log"); goto out_dump; } } if (sleb->endpt || c->lhead_offs >= c->leb_size) { c->lhead_lnum = lnum; c->lhead_offs = sleb->endpt; } err = !sleb->endpt; out: ubifs_scan_destroy(sleb); return err; out_dump: |
681947d2f UBIFS: minor spel... |
949 |
ubifs_err("log error detected while replaying the log at LEB %d:%d", |
1e51764a3 UBIFS: add new fl... |
950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 |
lnum, offs + snod->offs); dbg_dump_node(c, snod->node); ubifs_scan_destroy(sleb); return -EINVAL; } /** * take_ihead - update the status of the index head in lprops to 'taken'. * @c: UBIFS file-system description object * * This function returns the amount of free space in the index head LEB or a * negative error code. */ static int take_ihead(struct ubifs_info *c) { const struct ubifs_lprops *lp; int err, free; ubifs_get_lprops(c); lp = ubifs_lpt_lookup_dirty(c, c->ihead_lnum); if (IS_ERR(lp)) { err = PTR_ERR(lp); goto out; } free = lp->free; lp = ubifs_change_lp(c, lp, LPROPS_NC, LPROPS_NC, lp->flags | LPROPS_TAKEN, 0); if (IS_ERR(lp)) { err = PTR_ERR(lp); goto out; } err = free; out: ubifs_release_lprops(c); return err; } /** * ubifs_replay_journal - replay journal. * @c: UBIFS file-system description object * * This function scans the journal, replays and cleans it up. It makes sure all * memory data structures related to uncommitted journal are built (dirty TNC * tree, tree of buds, modified lprops, etc). */ int ubifs_replay_journal(struct ubifs_info *c) { int err, i, lnum, offs, free; |
1e51764a3 UBIFS: add new fl... |
1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 |
BUILD_BUG_ON(UBIFS_TRUN_KEY > 5); /* Update the status of the index head in lprops to 'taken' */ free = take_ihead(c); if (free < 0) return free; /* Error code */ if (c->ihead_offs != c->leb_size - free) { ubifs_err("bad index head LEB %d:%d", c->ihead_lnum, c->ihead_offs); return -EINVAL; } |
1e51764a3 UBIFS: add new fl... |
1015 |
dbg_mnt("start replaying the journal"); |
1e51764a3 UBIFS: add new fl... |
1016 |
c->replaying = 1; |
1e51764a3 UBIFS: add new fl... |
1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 |
lnum = c->ltail_lnum = c->lhead_lnum; offs = c->lhead_offs; for (i = 0; i < c->log_lebs; i++, lnum++) { if (lnum >= UBIFS_LOG_LNUM + c->log_lebs) { /* * The log is logically circular, we reached the last * LEB, switch to the first one. */ lnum = UBIFS_LOG_LNUM; offs = 0; } |
6599fcbd0 UBIFS: do not all... |
1029 |
err = replay_log_leb(c, lnum, offs, c->sbuf); |
1e51764a3 UBIFS: add new fl... |
1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 |
if (err == 1) /* We hit the end of the log */ break; if (err) goto out; offs = 0; } err = replay_buds(c); if (err) goto out; |
debf12d54 UBIFS: substitute... |
1041 |
err = apply_replay_list(c); |
1e51764a3 UBIFS: add new fl... |
1042 1043 |
if (err) goto out; |
074bcb9b5 UBIFS: simplify r... |
1044 1045 1046 |
err = set_buds_lprops(c); if (err) goto out; |
6edbfafda UBIFS: restore bu... |
1047 |
/* |
b137545c4 UBIFS: introduce ... |
1048 1049 |
* UBIFS budgeting calculations use @c->bi.uncommitted_idx variable * to roughly estimate index growth. Things like @c->bi.min_idx_lebs |
6edbfafda UBIFS: restore bu... |
1050 1051 1052 |
* depend on it. This means we have to initialize it to make sure * budgeting works properly. */ |
b137545c4 UBIFS: introduce ... |
1053 1054 |
c->bi.uncommitted_idx = atomic_long_read(&c->dirty_zn_cnt); c->bi.uncommitted_idx *= c->max_idx_node_sz; |
6edbfafda UBIFS: restore bu... |
1055 |
|
1e51764a3 UBIFS: add new fl... |
1056 1057 1058 |
ubifs_assert(c->bud_bytes <= c->max_bud_bytes || c->need_recovery); dbg_mnt("finished, log head LEB %d:%d, max_sqnum %llu, " "highest_inum %lu", c->lhead_lnum, c->lhead_offs, c->max_sqnum, |
e84461ad9 UBIFS: fix compil... |
1059 |
(unsigned long)c->highest_inum); |
1e51764a3 UBIFS: add new fl... |
1060 |
out: |
debf12d54 UBIFS: substitute... |
1061 |
destroy_replay_list(c); |
1e51764a3 UBIFS: add new fl... |
1062 |
destroy_bud_list(c); |
1e51764a3 UBIFS: add new fl... |
1063 1064 1065 |
c->replaying = 0; return err; } |