Blame view
fs/ubifs/scan.c
9.43 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 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 |
/* * 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 implements the scan which is a general-purpose function for * determining what nodes are in an eraseblock. The scan is used to replay the * journal, to do garbage collection. for the TNC in-the-gaps method, and by * debugging functions. */ #include "ubifs.h" /** * scan_padding_bytes - scan for padding bytes. * @buf: buffer to scan * @len: length of buffer * * This function returns the number of padding bytes on success and * %SCANNED_GARBAGE on failure. */ static int scan_padding_bytes(void *buf, int len) { int pad_len = 0, max_pad_len = min_t(int, UBIFS_PAD_NODE_SZ, len); uint8_t *p = buf; dbg_scan("not a node"); while (pad_len < max_pad_len && *p++ == UBIFS_PADDING_BYTE) pad_len += 1; if (!pad_len || (pad_len & 7)) return SCANNED_GARBAGE; dbg_scan("%d padding bytes", pad_len); return pad_len; } /** * ubifs_scan_a_node - scan for a node or padding. * @c: UBIFS file-system description object * @buf: buffer to scan * @len: length of buffer * @lnum: logical eraseblock number * @offs: offset within the logical eraseblock * @quiet: print no messages * * This function returns a scanning code to indicate what was scanned. */ int ubifs_scan_a_node(const struct ubifs_info *c, void *buf, int len, int lnum, int offs, int quiet) { struct ubifs_ch *ch = buf; uint32_t magic; magic = le32_to_cpu(ch->magic); if (magic == 0xFFFFFFFF) { dbg_scan("hit empty space"); return SCANNED_EMPTY_SPACE; } if (magic != UBIFS_NODE_MAGIC) return scan_padding_bytes(buf, len); if (len < UBIFS_CH_SZ) return SCANNED_GARBAGE; dbg_scan("scanning %s", dbg_ntype(ch->node_type)); |
2953e73f1 UBIFS: add no_chk... |
89 |
if (ubifs_check_node(c, buf, lnum, offs, quiet, 1)) |
1e51764a3 UBIFS: add new fl... |
90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 |
return SCANNED_A_CORRUPT_NODE; if (ch->node_type == UBIFS_PAD_NODE) { struct ubifs_pad_node *pad = buf; int pad_len = le32_to_cpu(pad->pad_len); int node_len = le32_to_cpu(ch->len); /* Validate the padding node */ if (pad_len < 0 || offs + node_len + pad_len > c->leb_size) { if (!quiet) { ubifs_err("bad pad node at LEB %d:%d", lnum, offs); dbg_dump_node(c, pad); } return SCANNED_A_BAD_PAD_NODE; } /* Make the node pads to 8-byte boundary */ if ((node_len + pad_len) & 7) { |
348709bad UBIFS: do not pri... |
110 |
if (!quiet) |
1e51764a3 UBIFS: add new fl... |
111 112 |
dbg_err("bad padding length %d - %d", offs, offs + node_len + pad_len); |
1e51764a3 UBIFS: add new fl... |
113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 |
return SCANNED_A_BAD_PAD_NODE; } dbg_scan("%d bytes padded, offset now %d", pad_len, ALIGN(offs + node_len + pad_len, 8)); return node_len + pad_len; } return SCANNED_A_NODE; } /** * ubifs_start_scan - create LEB scanning information at start of scan. * @c: UBIFS file-system description object * @lnum: logical eraseblock number * @offs: offset to start at (usually zero) * @sbuf: scan buffer (must be c->leb_size) * * This function returns %0 on success and a negative error code on failure. */ struct ubifs_scan_leb *ubifs_start_scan(const struct ubifs_info *c, int lnum, int offs, void *sbuf) { struct ubifs_scan_leb *sleb; int err; dbg_scan("scan LEB %d:%d", lnum, offs); sleb = kzalloc(sizeof(struct ubifs_scan_leb), GFP_NOFS); if (!sleb) return ERR_PTR(-ENOMEM); sleb->lnum = lnum; INIT_LIST_HEAD(&sleb->nodes); sleb->buf = sbuf; |
d304820a1 UBIFS: switch to ... |
149 |
err = ubifs_leb_read(c, lnum, sbuf + offs, offs, c->leb_size - offs, 0); |
1e51764a3 UBIFS: add new fl... |
150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 |
if (err && err != -EBADMSG) { ubifs_err("cannot read %d bytes from LEB %d:%d," " error %d", c->leb_size - offs, lnum, offs, err); kfree(sleb); return ERR_PTR(err); } if (err == -EBADMSG) sleb->ecc = 1; return sleb; } /** * ubifs_end_scan - update LEB scanning information at end of scan. * @c: UBIFS file-system description object * @sleb: scanning information * @lnum: logical eraseblock number * @offs: offset to start at (usually zero) * * This function returns %0 on success and a negative error code on failure. */ void ubifs_end_scan(const struct ubifs_info *c, struct ubifs_scan_leb *sleb, int lnum, int offs) { lnum = lnum; dbg_scan("stop scanning LEB %d at offset %d", lnum, offs); ubifs_assert(offs % c->min_io_size == 0); sleb->endpt = ALIGN(offs, c->min_io_size); } /** * ubifs_add_snod - add a scanned node to LEB scanning information. * @c: UBIFS file-system description object * @sleb: scanning information * @buf: buffer containing node * @offs: offset of node on flash * * This function returns %0 on success and a negative error code on failure. */ int ubifs_add_snod(const struct ubifs_info *c, struct ubifs_scan_leb *sleb, void *buf, int offs) { struct ubifs_ch *ch = buf; struct ubifs_ino_node *ino = buf; struct ubifs_scan_node *snod; |
ba2f48f70 UBIFS: mark unuse... |
197 |
snod = kmalloc(sizeof(struct ubifs_scan_node), GFP_NOFS); |
1e51764a3 UBIFS: add new fl... |
198 199 200 201 202 203 204 205 206 207 208 209 210 211 |
if (!snod) return -ENOMEM; snod->sqnum = le64_to_cpu(ch->sqnum); snod->type = ch->node_type; snod->offs = offs; snod->len = le32_to_cpu(ch->len); snod->node = buf; switch (ch->node_type) { case UBIFS_INO_NODE: case UBIFS_DENT_NODE: case UBIFS_XENT_NODE: case UBIFS_DATA_NODE: |
1e51764a3 UBIFS: add new fl... |
212 213 214 215 216 217 |
/* * The key is in the same place in all keyed * nodes. */ key_read(c, &ino->key, &snod->key); break; |
ba2f48f70 UBIFS: mark unuse... |
218 219 220 |
default: invalid_key_init(c, &snod->key); break; |
1e51764a3 UBIFS: add new fl... |
221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 |
} list_add_tail(&snod->list, &sleb->nodes); sleb->nodes_cnt += 1; return 0; } /** * ubifs_scanned_corruption - print information after UBIFS scanned corruption. * @c: UBIFS file-system description object * @lnum: LEB number of corruption * @offs: offset of corruption * @buf: buffer containing corruption */ void ubifs_scanned_corruption(const struct ubifs_info *c, int lnum, int offs, void *buf) { int len; |
086b3640c UBIFS: dump a lit... |
238 |
ubifs_err("corruption at LEB %d:%d", lnum, offs); |
2b1844a8c UBIFS: introduce ... |
239 |
if (dbg_is_tst_rcvry(c)) |
1e51764a3 UBIFS: add new fl... |
240 241 |
return; len = c->leb_size - offs; |
086b3640c UBIFS: dump a lit... |
242 243 |
if (len > 8192) len = 8192; |
1e51764a3 UBIFS: add new fl... |
244 245 246 247 248 249 250 251 252 |
dbg_err("first %d bytes from LEB %d:%d", len, lnum, offs); print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 4, buf, len, 1); } /** * ubifs_scan - scan a logical eraseblock. * @c: UBIFS file-system description object * @lnum: logical eraseblock number * @offs: offset to start at (usually zero) |
348709bad UBIFS: do not pri... |
253 254 |
* @sbuf: scan buffer (must be of @c->leb_size bytes in size) * @quiet: print no messages |
1e51764a3 UBIFS: add new fl... |
255 256 |
* * This function scans LEB number @lnum and returns complete information about |
ed43f2f06 UBIFS: small amen... |
257 258 259 |
* its contents. Returns the scaned information in case of success and, * %-EUCLEAN if the LEB neads recovery, and other negative error codes in case * of failure. |
348709bad UBIFS: do not pri... |
260 261 262 |
* * If @quiet is non-zero, this function does not print large and scary * error messages and flash dumps in case of errors. |
1e51764a3 UBIFS: add new fl... |
263 264 |
*/ struct ubifs_scan_leb *ubifs_scan(const struct ubifs_info *c, int lnum, |
348709bad UBIFS: do not pri... |
265 |
int offs, void *sbuf, int quiet) |
1e51764a3 UBIFS: add new fl... |
266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 |
{ void *buf = sbuf + offs; int err, len = c->leb_size - offs; struct ubifs_scan_leb *sleb; sleb = ubifs_start_scan(c, lnum, offs, sbuf); if (IS_ERR(sleb)) return sleb; while (len >= 8) { struct ubifs_ch *ch = buf; int node_len, ret; dbg_scan("look at LEB %d:%d (%d bytes left)", lnum, offs, len); cond_resched(); |
348709bad UBIFS: do not pri... |
283 |
ret = ubifs_scan_a_node(c, buf, len, lnum, offs, quiet); |
1e51764a3 UBIFS: add new fl... |
284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 |
if (ret > 0) { /* Padding bytes or a valid padding node */ offs += ret; buf += ret; len -= ret; continue; } if (ret == SCANNED_EMPTY_SPACE) /* Empty space is checked later */ break; switch (ret) { case SCANNED_GARBAGE: dbg_err("garbage"); goto corrupted; case SCANNED_A_NODE: break; case SCANNED_A_CORRUPT_NODE: case SCANNED_A_BAD_PAD_NODE: dbg_err("bad node"); goto corrupted; default: dbg_err("unknown"); |
ed43f2f06 UBIFS: small amen... |
308 309 |
err = -EINVAL; goto error; |
1e51764a3 UBIFS: add new fl... |
310 311 312 313 314 315 316 317 318 319 320 |
} err = ubifs_add_snod(c, sleb, buf, offs); if (err) goto error; node_len = ALIGN(le32_to_cpu(ch->len), 8); offs += node_len; buf += node_len; len -= node_len; } |
ed43f2f06 UBIFS: small amen... |
321 |
if (offs % c->min_io_size) { |
348709bad UBIFS: do not pri... |
322 323 324 |
if (!quiet) ubifs_err("empty space starts at non-aligned offset %d", offs); |
822ed64c5 UBIFS: remove dou... |
325 |
goto corrupted; |
ed43f2f06 UBIFS: small amen... |
326 |
} |
1e51764a3 UBIFS: add new fl... |
327 328 329 330 331 332 333 334 |
ubifs_end_scan(c, sleb, lnum, offs); for (; len > 4; offs += 4, buf = buf + 4, len -= 4) if (*(uint32_t *)buf != 0xffffffff) break; for (; len; offs++, buf++, len--) if (*(uint8_t *)buf != 0xff) { |
348709bad UBIFS: do not pri... |
335 336 337 |
if (!quiet) ubifs_err("corrupt empty space at LEB %d:%d", lnum, offs); |
1e51764a3 UBIFS: add new fl... |
338 339 340 341 342 343 |
goto corrupted; } return sleb; corrupted: |
348709bad UBIFS: do not pri... |
344 345 346 347 |
if (!quiet) { ubifs_scanned_corruption(c, lnum, offs, buf); ubifs_err("LEB %d scanning failed", lnum); } |
1e51764a3 UBIFS: add new fl... |
348 |
err = -EUCLEAN; |
348709bad UBIFS: do not pri... |
349 350 |
ubifs_scan_destroy(sleb); return ERR_PTR(err); |
1e51764a3 UBIFS: add new fl... |
351 |
error: |
348709bad UBIFS: do not pri... |
352 |
ubifs_err("LEB %d scanning failed, error %d", lnum, err); |
1e51764a3 UBIFS: add new fl... |
353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 |
ubifs_scan_destroy(sleb); return ERR_PTR(err); } /** * ubifs_scan_destroy - destroy LEB scanning information. * @sleb: scanning information to free */ void ubifs_scan_destroy(struct ubifs_scan_leb *sleb) { struct ubifs_scan_node *node; struct list_head *head; head = &sleb->nodes; while (!list_empty(head)) { node = list_entry(head->next, struct ubifs_scan_node, list); list_del(&node->list); kfree(node); } kfree(sleb); } |