1/* 2 * JFFS2 -- Journalling Flash File System, Version 2. 3 * 4 * Copyright �� 2001-2007 Red Hat, Inc. 5 * 6 * Created by David Woodhouse <dwmw2@infradead.org> 7 * 8 * For licensing information, see the file 'LICENCE' in this directory. 9 * 10 */ 11 12#include <linux/kernel.h> 13#include <linux/sched.h> 14#include <linux/slab.h> 15#include <linux/fs.h> 16#include <linux/crc32.h> 17#include <linux/pagemap.h> 18#include <linux/mtd/mtd.h> 19#include <linux/compiler.h> 20#include "nodelist.h" 21 22/* 23 * Check the data CRC of the node. 24 * 25 * Returns: 0 if the data CRC is correct; 26 * 1 - if incorrect; 27 * error code if an error occured. 28 */ 29static int check_node_data(struct jffs2_sb_info *c, struct jffs2_tmp_dnode_info *tn) 30{ 31 struct jffs2_raw_node_ref *ref = tn->fn->raw; 32 int err = 0, pointed = 0; 33 struct jffs2_eraseblock *jeb; 34 unsigned char *buffer; 35 uint32_t crc, ofs, len; 36 size_t retlen; 37 38 BUG_ON(tn->csize == 0); 39 40 /* Calculate how many bytes were already checked */ 41 ofs = ref_offset(ref) + sizeof(struct jffs2_raw_inode); 42 len = tn->csize; 43 44 if (jffs2_is_writebuffered(c)) { 45 int adj = ofs % c->wbuf_pagesize; 46 if (likely(adj)) 47 adj = c->wbuf_pagesize - adj; 48 49 if (adj >= tn->csize) { 50 dbg_readinode("no need to check node at %#08x, data length %u, data starts at %#08x - it has already been checked.\n", 51 ref_offset(ref), tn->csize, ofs); 52 goto adj_acc; 53 } 54 55 ofs += adj; 56 len -= adj; 57 } 58 59 dbg_readinode("check node at %#08x, data length %u, partial CRC %#08x, correct CRC %#08x, data starts at %#08x, start checking from %#08x - %u bytes.\n", 60 ref_offset(ref), tn->csize, tn->partial_crc, tn->data_crc, ofs - len, ofs, len); 61 62#ifndef __ECOS 63 /* TODO: instead, incapsulate point() stuff to jffs2_flash_read(), 64 * adding and jffs2_flash_read_end() interface. */ 65 if (c->mtd->point) { 66 err = c->mtd->point(c->mtd, ofs, len, &retlen, 67 (void **)&buffer, NULL); 68 if (!err && retlen < len) { 69 JFFS2_WARNING("MTD point returned len too short: %zu instead of %u.\n", retlen, tn->csize); 70 c->mtd->unpoint(c->mtd, ofs, retlen); 71 } else if (err) 72 JFFS2_WARNING("MTD point failed: error code %d.\n", err); 73 else 74 pointed = 1; /* succefully pointed to device */ 75 } 76#endif 77 78 if (!pointed) { 79 buffer = kmalloc(len, GFP_KERNEL); 80 if (unlikely(!buffer)) 81 return -ENOMEM; 82 83 /* TODO: this is very frequent pattern, make it a separate 84 * routine */ 85 err = jffs2_flash_read(c, ofs, len, &retlen, buffer); 86 if (err) { 87 JFFS2_ERROR("can not read %d bytes from 0x%08x, error code: %d.\n", len, ofs, err); 88 goto free_out; 89 } 90 91 if (retlen != len) { 92 JFFS2_ERROR("short read at %#08x: %zd instead of %d.\n", ofs, retlen, len); 93 err = -EIO; 94 goto free_out; 95 } 96 } 97 98 /* Continue calculating CRC */ 99 crc = crc32(tn->partial_crc, buffer, len); 100 if(!pointed) 101 kfree(buffer); 102#ifndef __ECOS 103 else 104 c->mtd->unpoint(c->mtd, ofs, len); 105#endif 106 107 if (crc != tn->data_crc) { 108 JFFS2_NOTICE("wrong data CRC in data node at 0x%08x: read %#08x, calculated %#08x.\n", 109 ref_offset(ref), tn->data_crc, crc); 110 return 1; 111 } 112 113adj_acc: 114 jeb = &c->blocks[ref->flash_offset / c->sector_size]; 115 len = ref_totlen(c, jeb, ref); 116 /* If it should be REF_NORMAL, it'll get marked as such when 117 we build the fragtree, shortly. No need to worry about GC 118 moving it while it's marked REF_PRISTINE -- GC won't happen 119 till we've finished checking every inode anyway. */ 120 ref->flash_offset |= REF_PRISTINE; 121 /* 122 * Mark the node as having been checked and fix the 123 * accounting accordingly. 124 */ 125 spin_lock(&c->erase_completion_lock); 126 jeb->used_size += len; 127 jeb->unchecked_size -= len; 128 c->used_size += len; 129 c->unchecked_size -= len; 130 jffs2_dbg_acct_paranoia_check_nolock(c, jeb); 131 spin_unlock(&c->erase_completion_lock); 132 133 return 0; 134 135free_out: 136 if(!pointed) 137 kfree(buffer); 138#ifndef __ECOS 139 else 140 c->mtd->unpoint(c->mtd, ofs, len); 141#endif 142 return err; 143} 144 145/* 146 * Helper function for jffs2_add_older_frag_to_fragtree(). 147 * 148 * Checks the node if we are in the checking stage. 149 */ 150static int check_tn_node(struct jffs2_sb_info *c, struct jffs2_tmp_dnode_info *tn) 151{ 152 int ret; 153 154 BUG_ON(ref_obsolete(tn->fn->raw)); 155 156 /* We only check the data CRC of unchecked nodes */ 157 if (ref_flags(tn->fn->raw) != REF_UNCHECKED) 158 return 0; 159 160 dbg_readinode("check node %#04x-%#04x, phys offs %#08x\n", 161 tn->fn->ofs, tn->fn->ofs + tn->fn->size, ref_offset(tn->fn->raw)); 162 163 ret = check_node_data(c, tn); 164 if (unlikely(ret < 0)) { 165 JFFS2_ERROR("check_node_data() returned error: %d.\n", 166 ret); 167 } else if (unlikely(ret > 0)) { 168 dbg_readinode("CRC error, mark it obsolete.\n"); 169 jffs2_mark_node_obsolete(c, tn->fn->raw); 170 } 171 172 return ret; 173} 174 175static struct jffs2_tmp_dnode_info *jffs2_lookup_tn(struct rb_root *tn_root, uint32_t offset) 176{ 177 struct rb_node *next; 178 struct jffs2_tmp_dnode_info *tn = NULL; 179 180 dbg_readinode("root %p, offset %d\n", tn_root, offset); 181 182 next = tn_root->rb_node; 183 184 while (next) { 185 tn = rb_entry(next, struct jffs2_tmp_dnode_info, rb); 186 187 if (tn->fn->ofs < offset) 188 next = tn->rb.rb_right; 189 else if (tn->fn->ofs >= offset) 190 next = tn->rb.rb_left; 191 else 192 break; 193 } 194 195 return tn; 196} 197 198 199static void jffs2_kill_tn(struct jffs2_sb_info *c, struct jffs2_tmp_dnode_info *tn) 200{ 201 jffs2_mark_node_obsolete(c, tn->fn->raw); 202 jffs2_free_full_dnode(tn->fn); 203 jffs2_free_tmp_dnode_info(tn); 204} 205/* 206 * This function is used when we read an inode. Data nodes arrive in 207 * arbitrary order -- they may be older or newer than the nodes which 208 * are already in the tree. Where overlaps occur, the older node can 209 * be discarded as long as the newer passes the CRC check. We don't 210 * bother to keep track of holes in this rbtree, and neither do we deal 211 * with frags -- we can have multiple entries starting at the same 212 * offset, and the one with the smallest length will come first in the 213 * ordering. 214 * 215 * Returns 0 if the node was handled (including marking it obsolete) 216 * < 0 an if error occurred 217 */ 218static int jffs2_add_tn_to_tree(struct jffs2_sb_info *c, 219 struct jffs2_readinode_info *rii, 220 struct jffs2_tmp_dnode_info *tn) 221{ 222 uint32_t fn_end = tn->fn->ofs + tn->fn->size; 223 struct jffs2_tmp_dnode_info *this, *ptn; 224 225 dbg_readinode("insert fragment %#04x-%#04x, ver %u at %08x\n", tn->fn->ofs, fn_end, tn->version, ref_offset(tn->fn->raw)); 226 227 /* If a node has zero dsize, we only have to keep if it if it might be the 228 node with highest version -- i.e. the one which will end up as f->metadata. 229 Note that such nodes won't be REF_UNCHECKED since there are no data to 230 check anyway. */ 231 if (!tn->fn->size) { 232 if (rii->mdata_tn) { 233 if (rii->mdata_tn->version < tn->version) { 234 /* We had a candidate mdata node already */ 235 dbg_readinode("kill old mdata with ver %d\n", rii->mdata_tn->version); 236 jffs2_kill_tn(c, rii->mdata_tn); 237 } else { 238 dbg_readinode("kill new mdata with ver %d (older than existing %d\n", 239 tn->version, rii->mdata_tn->version); 240 jffs2_kill_tn(c, tn); 241 return 0; 242 } 243 } 244 rii->mdata_tn = tn; 245 dbg_readinode("keep new mdata with ver %d\n", tn->version); 246 return 0; 247 } 248 249 /* Find the earliest node which _may_ be relevant to this one */ 250 this = jffs2_lookup_tn(&rii->tn_root, tn->fn->ofs); 251 if (this) { 252 /* If the node is coincident with another at a lower address, 253 back up until the other node is found. It may be relevant */ 254 while (this->overlapped) { 255 ptn = tn_prev(this); 256 if (!ptn) { 257 /* 258 * We killed a node which set the overlapped 259 * flags during the scan. Fix it up. 260 */ 261 this->overlapped = 0; 262 break; 263 } 264 this = ptn; 265 } 266 dbg_readinode("'this' found %#04x-%#04x (%s)\n", this->fn->ofs, this->fn->ofs + this->fn->size, this->fn ? "data" : "hole"); 267 } 268 269 while (this) { 270 if (this->fn->ofs > fn_end) 271 break; 272 dbg_readinode("Ponder this ver %d, 0x%x-0x%x\n", 273 this->version, this->fn->ofs, this->fn->size); 274 275 if (this->version == tn->version) { 276 /* Version number collision means REF_PRISTINE GC. Accept either of them 277 as long as the CRC is correct. Check the one we have already... */ 278 if (!check_tn_node(c, this)) { 279 /* The one we already had was OK. Keep it and throw away the new one */ 280 dbg_readinode("Like old node. Throw away new\n"); 281 jffs2_kill_tn(c, tn); 282 return 0; 283 } else { 284 /* Who cares if the new one is good; keep it for now anyway. */ 285 dbg_readinode("Like new node. Throw away old\n"); 286 rb_replace_node(&this->rb, &tn->rb, &rii->tn_root); 287 jffs2_kill_tn(c, this); 288 /* Same overlapping from in front and behind */ 289 return 0; 290 } 291 } 292 if (this->version < tn->version && 293 this->fn->ofs >= tn->fn->ofs && 294 this->fn->ofs + this->fn->size <= fn_end) { 295 /* New node entirely overlaps 'this' */ 296 if (check_tn_node(c, tn)) { 297 dbg_readinode("new node bad CRC\n"); 298 jffs2_kill_tn(c, tn); 299 return 0; 300 } 301 /* ... and is good. Kill 'this' and any subsequent nodes which are also overlapped */ 302 while (this && this->fn->ofs + this->fn->size <= fn_end) { 303 struct jffs2_tmp_dnode_info *next = tn_next(this); 304 if (this->version < tn->version) { 305 tn_erase(this, &rii->tn_root); 306 dbg_readinode("Kill overlapped ver %d, 0x%x-0x%x\n", 307 this->version, this->fn->ofs, 308 this->fn->ofs+this->fn->size); 309 jffs2_kill_tn(c, this); 310 } 311 this = next; 312 } 313 dbg_readinode("Done killing overlapped nodes\n"); 314 continue; 315 } 316 if (this->version > tn->version && 317 this->fn->ofs <= tn->fn->ofs && 318 this->fn->ofs+this->fn->size >= fn_end) { 319 /* New node entirely overlapped by 'this' */ 320 if (!check_tn_node(c, this)) { 321 dbg_readinode("Good CRC on old node. Kill new\n"); 322 jffs2_kill_tn(c, tn); 323 return 0; 324 } 325 /* ... but 'this' was bad. Replace it... */ 326 dbg_readinode("Bad CRC on old overlapping node. Kill it\n"); 327 tn_erase(this, &rii->tn_root); 328 jffs2_kill_tn(c, this); 329 break; 330 } 331 332 this = tn_next(this); 333 } 334 335 /* We neither completely obsoleted nor were completely 336 obsoleted by an earlier node. Insert into the tree */ 337 { 338 struct rb_node *parent; 339 struct rb_node **link = &rii->tn_root.rb_node; 340 struct jffs2_tmp_dnode_info *insert_point = NULL; 341 342 while (*link) { 343 parent = *link; 344 insert_point = rb_entry(parent, struct jffs2_tmp_dnode_info, rb); 345 if (tn->fn->ofs > insert_point->fn->ofs) 346 link = &insert_point->rb.rb_right; 347 else if (tn->fn->ofs < insert_point->fn->ofs || 348 tn->fn->size < insert_point->fn->size) 349 link = &insert_point->rb.rb_left; 350 else 351 link = &insert_point->rb.rb_right; 352 } 353 rb_link_node(&tn->rb, &insert_point->rb, link); 354 rb_insert_color(&tn->rb, &rii->tn_root); 355 } 356 357 /* If there's anything behind that overlaps us, note it */ 358 this = tn_prev(tn); 359 if (this) { 360 while (1) { 361 if (this->fn->ofs + this->fn->size > tn->fn->ofs) { 362 dbg_readinode("Node is overlapped by %p (v %d, 0x%x-0x%x)\n", 363 this, this->version, this->fn->ofs, 364 this->fn->ofs+this->fn->size); 365 tn->overlapped = 1; 366 break; 367 } 368 if (!this->overlapped) 369 break; 370 371 ptn = tn_prev(this); 372 if (!ptn) { 373 /* 374 * We killed a node which set the overlapped 375 * flags during the scan. Fix it up. 376 */ 377 this->overlapped = 0; 378 break; 379 } 380 this = ptn; 381 } 382 } 383 384 /* If the new node overlaps anything ahead, note it */ 385 this = tn_next(tn); 386 while (this && this->fn->ofs < fn_end) { 387 this->overlapped = 1; 388 dbg_readinode("Node ver %d, 0x%x-0x%x is overlapped\n", 389 this->version, this->fn->ofs, 390 this->fn->ofs+this->fn->size); 391 this = tn_next(this); 392 } 393 return 0; 394} 395 396/* Trivial function to remove the last node in the tree. Which by definition 397 has no right-hand -- so can be removed just by making its only child (if 398 any) take its place under its parent. */ 399static void eat_last(struct rb_root *root, struct rb_node *node) 400{ 401 struct rb_node *parent = rb_parent(node); 402 struct rb_node **link; 403 404 /* LAST! */ 405 BUG_ON(node->rb_right); 406 407 if (!parent) 408 link = &root->rb_node; 409 else if (node == parent->rb_left) 410 link = &parent->rb_left; 411 else 412 link = &parent->rb_right; 413 414 *link = node->rb_left; 415 /* Colour doesn't matter now. Only the parent pointer. */ 416 if (node->rb_left) 417 node->rb_left->rb_parent_color = node->rb_parent_color; 418} 419 420/* We put this in reverse order, so we can just use eat_last */ 421static void ver_insert(struct rb_root *ver_root, struct jffs2_tmp_dnode_info *tn) 422{ 423 struct rb_node **link = &ver_root->rb_node; 424 struct rb_node *parent = NULL; 425 struct jffs2_tmp_dnode_info *this_tn; 426 427 while (*link) { 428 parent = *link; 429 this_tn = rb_entry(parent, struct jffs2_tmp_dnode_info, rb); 430 431 if (tn->version > this_tn->version) 432 link = &parent->rb_left; 433 else 434 link = &parent->rb_right; 435 } 436 dbg_readinode("Link new node at %p (root is %p)\n", link, ver_root); 437 rb_link_node(&tn->rb, parent, link); 438 rb_insert_color(&tn->rb, ver_root); 439} 440 441/* Build final, normal fragtree from tn tree. It doesn't matter which order 442 we add nodes to the real fragtree, as long as they don't overlap. And 443 having thrown away the majority of overlapped nodes as we went, there 444 really shouldn't be many sets of nodes which do overlap. If we start at 445 the end, we can use the overlap markers -- we can just eat nodes which 446 aren't overlapped, and when we encounter nodes which _do_ overlap we 447 sort them all into a temporary tree in version order before replaying them. */ 448static int jffs2_build_inode_fragtree(struct jffs2_sb_info *c, 449 struct jffs2_inode_info *f, 450 struct jffs2_readinode_info *rii) 451{ 452 struct jffs2_tmp_dnode_info *pen, *last, *this; 453 struct rb_root ver_root = RB_ROOT; 454 uint32_t high_ver = 0; 455 456 if (rii->mdata_tn) { 457 dbg_readinode("potential mdata is ver %d at %p\n", rii->mdata_tn->version, rii->mdata_tn); 458 high_ver = rii->mdata_tn->version; 459 rii->latest_ref = rii->mdata_tn->fn->raw; 460 } 461#ifdef JFFS2_DBG_READINODE_MESSAGES 462 this = tn_last(&rii->tn_root); 463 while (this) { 464 dbg_readinode("tn %p ver %d range 0x%x-0x%x ov %d\n", this, this->version, this->fn->ofs, 465 this->fn->ofs+this->fn->size, this->overlapped); 466 this = tn_prev(this); 467 } 468#endif 469 pen = tn_last(&rii->tn_root); 470 while ((last = pen)) { 471 pen = tn_prev(last); 472 473 eat_last(&rii->tn_root, &last->rb); 474 ver_insert(&ver_root, last); 475 476 if (unlikely(last->overlapped)) { 477 if (pen) 478 continue; 479 /* 480 * We killed a node which set the overlapped 481 * flags during the scan. Fix it up. 482 */ 483 last->overlapped = 0; 484 } 485 486 /* Now we have a bunch of nodes in reverse version 487 order, in the tree at ver_root. Most of the time, 488 there'll actually be only one node in the 'tree', 489 in fact. */ 490 this = tn_last(&ver_root); 491 492 while (this) { 493 struct jffs2_tmp_dnode_info *vers_next; 494 int ret; 495 vers_next = tn_prev(this); 496 eat_last(&ver_root, &this->rb); 497 if (check_tn_node(c, this)) { 498 dbg_readinode("node ver %d, 0x%x-0x%x failed CRC\n", 499 this->version, this->fn->ofs, 500 this->fn->ofs+this->fn->size); 501 jffs2_kill_tn(c, this); 502 } else { 503 if (this->version > high_ver) { 504 /* Note that this is different from the other 505 highest_version, because this one is only 506 counting _valid_ nodes which could give the 507 latest inode metadata */ 508 high_ver = this->version; 509 rii->latest_ref = this->fn->raw; 510 } 511 dbg_readinode("Add %p (v %d, 0x%x-0x%x, ov %d) to fragtree\n", 512 this, this->version, this->fn->ofs, 513 this->fn->ofs+this->fn->size, this->overlapped); 514 515 ret = jffs2_add_full_dnode_to_inode(c, f, this->fn); 516 if (ret) { 517 /* Free the nodes in vers_root; let the caller 518 deal with the rest */ 519 JFFS2_ERROR("Add node to tree failed %d\n", ret); 520 while (1) { 521 vers_next = tn_prev(this); 522 if (check_tn_node(c, this)) 523 jffs2_mark_node_obsolete(c, this->fn->raw); 524 jffs2_free_full_dnode(this->fn); 525 jffs2_free_tmp_dnode_info(this); 526 this = vers_next; 527 if (!this) 528 break; 529 eat_last(&ver_root, &vers_next->rb); 530 } 531 return ret; 532 } 533 jffs2_free_tmp_dnode_info(this); 534 } 535 this = vers_next; 536 } 537 } 538 return 0; 539} 540 541static void jffs2_free_tmp_dnode_info_list(struct rb_root *list) 542{ 543 struct rb_node *this; 544 struct jffs2_tmp_dnode_info *tn; 545 546 this = list->rb_node; 547 548 /* Now at bottom of tree */ 549 while (this) { 550 if (this->rb_left) 551 this = this->rb_left; 552 else if (this->rb_right) 553 this = this->rb_right; 554 else { 555 tn = rb_entry(this, struct jffs2_tmp_dnode_info, rb); 556 jffs2_free_full_dnode(tn->fn); 557 jffs2_free_tmp_dnode_info(tn); 558 559 this = rb_parent(this); 560 if (!this) 561 break; 562 563 if (this->rb_left == &tn->rb) 564 this->rb_left = NULL; 565 else if (this->rb_right == &tn->rb) 566 this->rb_right = NULL; 567 else BUG(); 568 } 569 } 570 *list = RB_ROOT; 571} 572 573static void jffs2_free_full_dirent_list(struct jffs2_full_dirent *fd) 574{ 575 struct jffs2_full_dirent *next; 576 577 while (fd) { 578 next = fd->next; 579 jffs2_free_full_dirent(fd); 580 fd = next; 581 } 582} 583 584/* Returns first valid node after 'ref'. May return 'ref' */ 585static struct jffs2_raw_node_ref *jffs2_first_valid_node(struct jffs2_raw_node_ref *ref) 586{ 587 while (ref && ref->next_in_ino) { 588 if (!ref_obsolete(ref)) 589 return ref; 590 dbg_noderef("node at 0x%08x is obsoleted. Ignoring.\n", ref_offset(ref)); 591 ref = ref->next_in_ino; 592 } 593 return NULL; 594} 595 596/* 597 * Helper function for jffs2_get_inode_nodes(). 598 * It is called every time an directory entry node is found. 599 * 600 * Returns: 0 on success; 601 * negative error code on failure. 602 */ 603static inline int read_direntry(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref, 604 struct jffs2_raw_dirent *rd, size_t read, 605 struct jffs2_readinode_info *rii) 606{ 607 struct jffs2_full_dirent *fd; 608 uint32_t crc; 609 610 /* Obsoleted. This cannot happen, surely? dwmw2 20020308 */ 611 BUG_ON(ref_obsolete(ref)); 612 613 crc = crc32(0, rd, sizeof(*rd) - 8); 614 if (unlikely(crc != je32_to_cpu(rd->node_crc))) { 615 JFFS2_NOTICE("header CRC failed on dirent node at %#08x: read %#08x, calculated %#08x\n", 616 ref_offset(ref), je32_to_cpu(rd->node_crc), crc); 617 jffs2_mark_node_obsolete(c, ref); 618 return 0; 619 } 620 621 /* If we've never checked the CRCs on this node, check them now */ 622 if (ref_flags(ref) == REF_UNCHECKED) { 623 struct jffs2_eraseblock *jeb; 624 int len; 625 626 /* Sanity check */ 627 if (unlikely(PAD((rd->nsize + sizeof(*rd))) != PAD(je32_to_cpu(rd->totlen)))) { 628 JFFS2_ERROR("illegal nsize in node at %#08x: nsize %#02x, totlen %#04x\n", 629 ref_offset(ref), rd->nsize, je32_to_cpu(rd->totlen)); 630 jffs2_mark_node_obsolete(c, ref); 631 return 0; 632 } 633 634 jeb = &c->blocks[ref->flash_offset / c->sector_size]; 635 len = ref_totlen(c, jeb, ref); 636 637 spin_lock(&c->erase_completion_lock); 638 jeb->used_size += len; 639 jeb->unchecked_size -= len; 640 c->used_size += len; 641 c->unchecked_size -= len; 642 ref->flash_offset = ref_offset(ref) | dirent_node_state(rd); 643 spin_unlock(&c->erase_completion_lock); 644 } 645 646 fd = jffs2_alloc_full_dirent(rd->nsize + 1); 647 if (unlikely(!fd)) 648 return -ENOMEM; 649 650 fd->raw = ref; 651 fd->version = je32_to_cpu(rd->version); 652 fd->ino = je32_to_cpu(rd->ino); 653 fd->type = rd->type; 654 655 if (fd->version > rii->highest_version) 656 rii->highest_version = fd->version; 657 658 /* Pick out the mctime of the latest dirent */ 659 if(fd->version > rii->mctime_ver && je32_to_cpu(rd->mctime)) { 660 rii->mctime_ver = fd->version; 661 rii->latest_mctime = je32_to_cpu(rd->mctime); 662 } 663 664 /* 665 * Copy as much of the name as possible from the raw 666 * dirent we've already read from the flash. 667 */ 668 if (read > sizeof(*rd)) 669 memcpy(&fd->name[0], &rd->name[0], 670 min_t(uint32_t, rd->nsize, (read - sizeof(*rd)) )); 671 672 /* Do we need to copy any more of the name directly from the flash? */ 673 if (rd->nsize + sizeof(*rd) > read) { 674 int err; 675 int already = read - sizeof(*rd); 676 677 err = jffs2_flash_read(c, (ref_offset(ref)) + read, 678 rd->nsize - already, &read, &fd->name[already]); 679 if (unlikely(read != rd->nsize - already) && likely(!err)) 680 return -EIO; 681 682 if (unlikely(err)) { 683 JFFS2_ERROR("read remainder of name: error %d\n", err); 684 jffs2_free_full_dirent(fd); 685 return -EIO; 686 } 687 } 688 689 fd->nhash = full_name_hash(fd->name, rd->nsize); 690 fd->next = NULL; 691 fd->name[rd->nsize] = '\0'; 692 693 /* 694 * Wheee. We now have a complete jffs2_full_dirent structure, with 695 * the name in it and everything. Link it into the list 696 */ 697 jffs2_add_fd_to_list(c, fd, &rii->fds); 698 699 return 0; 700} 701 702/* 703 * Helper function for jffs2_get_inode_nodes(). 704 * It is called every time an inode node is found. 705 * 706 * Returns: 0 on success (possibly after marking a bad node obsolete); 707 * negative error code on failure. 708 */ 709static inline int read_dnode(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref, 710 struct jffs2_raw_inode *rd, int rdlen, 711 struct jffs2_readinode_info *rii) 712{ 713 struct jffs2_tmp_dnode_info *tn; 714 uint32_t len, csize; 715 int ret = 0; 716 uint32_t crc; 717 718 /* Obsoleted. This cannot happen, surely? dwmw2 20020308 */ 719 BUG_ON(ref_obsolete(ref)); 720 721 crc = crc32(0, rd, sizeof(*rd) - 8); 722 if (unlikely(crc != je32_to_cpu(rd->node_crc))) { 723 JFFS2_NOTICE("node CRC failed on dnode at %#08x: read %#08x, calculated %#08x\n", 724 ref_offset(ref), je32_to_cpu(rd->node_crc), crc); 725 jffs2_mark_node_obsolete(c, ref); 726 return 0; 727 } 728 729 tn = jffs2_alloc_tmp_dnode_info(); 730 if (!tn) { 731 JFFS2_ERROR("failed to allocate tn (%zu bytes).\n", sizeof(*tn)); 732 return -ENOMEM; 733 } 734 735 tn->partial_crc = 0; 736 csize = je32_to_cpu(rd->csize); 737 738 /* If we've never checked the CRCs on this node, check them now */ 739 if (ref_flags(ref) == REF_UNCHECKED) { 740 741 /* Sanity checks */ 742 if (unlikely(je32_to_cpu(rd->offset) > je32_to_cpu(rd->isize)) || 743 unlikely(PAD(je32_to_cpu(rd->csize) + sizeof(*rd)) != PAD(je32_to_cpu(rd->totlen)))) { 744 JFFS2_WARNING("inode node header CRC is corrupted at %#08x\n", ref_offset(ref)); 745 jffs2_dbg_dump_node(c, ref_offset(ref)); 746 jffs2_mark_node_obsolete(c, ref); 747 goto free_out; 748 } 749 750 if (jffs2_is_writebuffered(c) && csize != 0) { 751 /* At this point we are supposed to check the data CRC 752 * of our unchecked node. But thus far, we do not 753 * know whether the node is valid or obsolete. To 754 * figure this out, we need to walk all the nodes of 755 * the inode and build the inode fragtree. We don't 756 * want to spend time checking data of nodes which may 757 * later be found to be obsolete. So we put off the full 758 * data CRC checking until we have read all the inode 759 * nodes and have started building the fragtree. 760 * 761 * The fragtree is being built starting with nodes 762 * having the highest version number, so we'll be able 763 * to detect whether a node is valid (i.e., it is not 764 * overlapped by a node with higher version) or not. 765 * And we'll be able to check only those nodes, which 766 * are not obsolete. 767 * 768 * Of course, this optimization only makes sense in case 769 * of NAND flashes (or other flashes with 770 * !jffs2_can_mark_obsolete()), since on NOR flashes 771 * nodes are marked obsolete physically. 772 * 773 * Since NAND flashes (or other flashes with 774 * jffs2_is_writebuffered(c)) are anyway read by 775 * fractions of c->wbuf_pagesize, and we have just read 776 * the node header, it is likely that the starting part 777 * of the node data is also read when we read the 778 * header. So we don't mind to check the CRC of the 779 * starting part of the data of the node now, and check 780 * the second part later (in jffs2_check_node_data()). 781 * Of course, we will not need to re-read and re-check 782 * the NAND page which we have just read. This is why we 783 * read the whole NAND page at jffs2_get_inode_nodes(), 784 * while we needed only the node header. 785 */ 786 unsigned char *buf; 787 788 /* 'buf' will point to the start of data */ 789 buf = (unsigned char *)rd + sizeof(*rd); 790 /* len will be the read data length */ 791 len = min_t(uint32_t, rdlen - sizeof(*rd), csize); 792 tn->partial_crc = crc32(0, buf, len); 793 794 dbg_readinode("Calculates CRC (%#08x) for %d bytes, csize %d\n", tn->partial_crc, len, csize); 795 796 /* If we actually calculated the whole data CRC 797 * and it is wrong, drop the node. */ 798 if (len >= csize && unlikely(tn->partial_crc != je32_to_cpu(rd->data_crc))) { 799 JFFS2_NOTICE("wrong data CRC in data node at 0x%08x: read %#08x, calculated %#08x.\n", 800 ref_offset(ref), tn->partial_crc, je32_to_cpu(rd->data_crc)); 801 jffs2_mark_node_obsolete(c, ref); 802 goto free_out; 803 } 804 805 } else if (csize == 0) { 806 /* 807 * We checked the header CRC. If the node has no data, adjust 808 * the space accounting now. For other nodes this will be done 809 * later either when the node is marked obsolete or when its 810 * data is checked. 811 */ 812 struct jffs2_eraseblock *jeb; 813 814 dbg_readinode("the node has no data.\n"); 815 jeb = &c->blocks[ref->flash_offset / c->sector_size]; 816 len = ref_totlen(c, jeb, ref); 817 818 spin_lock(&c->erase_completion_lock); 819 jeb->used_size += len; 820 jeb->unchecked_size -= len; 821 c->used_size += len; 822 c->unchecked_size -= len; 823 ref->flash_offset = ref_offset(ref) | REF_NORMAL; 824 spin_unlock(&c->erase_completion_lock); 825 } 826 } 827 828 tn->fn = jffs2_alloc_full_dnode(); 829 if (!tn->fn) { 830 JFFS2_ERROR("alloc fn failed\n"); 831 ret = -ENOMEM; 832 goto free_out; 833 } 834 835 tn->version = je32_to_cpu(rd->version); 836 tn->fn->ofs = je32_to_cpu(rd->offset); 837 tn->data_crc = je32_to_cpu(rd->data_crc); 838 tn->csize = csize; 839 tn->fn->raw = ref; 840 tn->overlapped = 0; 841 842 if (tn->version > rii->highest_version) 843 rii->highest_version = tn->version; 844 845 /* There was a bug where we wrote hole nodes out with 846 csize/dsize swapped. Deal with it */ 847 if (rd->compr == JFFS2_COMPR_ZERO && !je32_to_cpu(rd->dsize) && csize) 848 tn->fn->size = csize; 849 else // normal case... 850 tn->fn->size = je32_to_cpu(rd->dsize); 851 852 dbg_readinode2("dnode @%08x: ver %u, offset %#04x, dsize %#04x, csize %#04x\n", 853 ref_offset(ref), je32_to_cpu(rd->version), 854 je32_to_cpu(rd->offset), je32_to_cpu(rd->dsize), csize); 855 856 ret = jffs2_add_tn_to_tree(c, rii, tn); 857 858 if (ret) { 859 jffs2_free_full_dnode(tn->fn); 860 free_out: 861 jffs2_free_tmp_dnode_info(tn); 862 return ret; 863 } 864#ifdef JFFS2_DBG_READINODE2_MESSAGES 865 dbg_readinode2("After adding ver %d:\n", je32_to_cpu(rd->version)); 866 tn = tn_first(&rii->tn_root); 867 while (tn) { 868 dbg_readinode2("%p: v %d r 0x%x-0x%x ov %d\n", 869 tn, tn->version, tn->fn->ofs, 870 tn->fn->ofs+tn->fn->size, tn->overlapped); 871 tn = tn_next(tn); 872 } 873#endif 874 return 0; 875} 876 877/* 878 * Helper function for jffs2_get_inode_nodes(). 879 * It is called every time an unknown node is found. 880 * 881 * Returns: 0 on success; 882 * negative error code on failure. 883 */ 884static inline int read_unknown(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref, struct jffs2_unknown_node *un) 885{ 886 /* We don't mark unknown nodes as REF_UNCHECKED */ 887 if (ref_flags(ref) == REF_UNCHECKED) { 888 JFFS2_ERROR("REF_UNCHECKED but unknown node at %#08x\n", 889 ref_offset(ref)); 890 JFFS2_ERROR("Node is {%04x,%04x,%08x,%08x}. Please report this error.\n", 891 je16_to_cpu(un->magic), je16_to_cpu(un->nodetype), 892 je32_to_cpu(un->totlen), je32_to_cpu(un->hdr_crc)); 893 jffs2_mark_node_obsolete(c, ref); 894 return 0; 895 } 896 897 un->nodetype = cpu_to_je16(JFFS2_NODE_ACCURATE | je16_to_cpu(un->nodetype)); 898 899 switch(je16_to_cpu(un->nodetype) & JFFS2_COMPAT_MASK) { 900 901 case JFFS2_FEATURE_INCOMPAT: 902 JFFS2_ERROR("unknown INCOMPAT nodetype %#04X at %#08x\n", 903 je16_to_cpu(un->nodetype), ref_offset(ref)); 904 /* EEP */ 905 BUG(); 906 break; 907 908 case JFFS2_FEATURE_ROCOMPAT: 909 JFFS2_ERROR("unknown ROCOMPAT nodetype %#04X at %#08x\n", 910 je16_to_cpu(un->nodetype), ref_offset(ref)); 911 BUG_ON(!(c->flags & JFFS2_SB_FLAG_RO)); 912 break; 913 914 case JFFS2_FEATURE_RWCOMPAT_COPY: 915 JFFS2_NOTICE("unknown RWCOMPAT_COPY nodetype %#04X at %#08x\n", 916 je16_to_cpu(un->nodetype), ref_offset(ref)); 917 break; 918 919 case JFFS2_FEATURE_RWCOMPAT_DELETE: 920 JFFS2_NOTICE("unknown RWCOMPAT_DELETE nodetype %#04X at %#08x\n", 921 je16_to_cpu(un->nodetype), ref_offset(ref)); 922 jffs2_mark_node_obsolete(c, ref); 923 return 0; 924 } 925 926 return 0; 927} 928 929/* 930 * Helper function for jffs2_get_inode_nodes(). 931 * The function detects whether more data should be read and reads it if yes. 932 * 933 * Returns: 0 on success; 934 * negative error code on failure. 935 */ 936static int read_more(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref, 937 int needed_len, int *rdlen, unsigned char *buf) 938{ 939 int err, to_read = needed_len - *rdlen; 940 size_t retlen; 941 uint32_t offs; 942 943 if (jffs2_is_writebuffered(c)) { 944 int rem = to_read % c->wbuf_pagesize; 945 946 if (rem) 947 to_read += c->wbuf_pagesize - rem; 948 } 949 950 /* We need to read more data */ 951 offs = ref_offset(ref) + *rdlen; 952 953 dbg_readinode("read more %d bytes\n", to_read); 954 955 err = jffs2_flash_read(c, offs, to_read, &retlen, buf + *rdlen); 956 if (err) { 957 JFFS2_ERROR("can not read %d bytes from 0x%08x, " 958 "error code: %d.\n", to_read, offs, err); 959 return err; 960 } 961 962 if (retlen < to_read) { 963 JFFS2_ERROR("short read at %#08x: %zu instead of %d.\n", 964 offs, retlen, to_read); 965 return -EIO; 966 } 967 968 *rdlen += to_read; 969 return 0; 970} 971 972/* Get tmp_dnode_info and full_dirent for all non-obsolete nodes associated 973 with this ino. Perform a preliminary ordering on data nodes, throwing away 974 those which are completely obsoleted by newer ones. The na��ve approach we 975 use to take of just returning them _all_ in version order will cause us to 976 run out of memory in certain degenerate cases. */ 977static int jffs2_get_inode_nodes(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 978 struct jffs2_readinode_info *rii) 979{ 980 struct jffs2_raw_node_ref *ref, *valid_ref; 981 unsigned char *buf = NULL; 982 union jffs2_node_union *node; 983 size_t retlen; 984 int len, err; 985 986 rii->mctime_ver = 0; 987 988 dbg_readinode("ino #%u\n", f->inocache->ino); 989 990 len = sizeof(union jffs2_node_union) + c->wbuf_pagesize; 991 buf = kmalloc(len, GFP_KERNEL); 992 if (!buf) 993 return -ENOMEM; 994 995 spin_lock(&c->erase_completion_lock); 996 valid_ref = jffs2_first_valid_node(f->inocache->nodes); 997 if (!valid_ref && f->inocache->ino != 1) 998 JFFS2_WARNING("Eep. No valid nodes for ino #%u.\n", f->inocache->ino); 999 while (valid_ref) { 1000 /* We can hold a pointer to a non-obsolete node without the spinlock, 1001 but _obsolete_ nodes may disappear at any time, if the block 1002 they're in gets erased. So if we mark 'ref' obsolete while we're 1003 not holding the lock, it can go away immediately. For that reason, 1004 we find the next valid node first, before processing 'ref'. 1005 */ 1006 ref = valid_ref; 1007 valid_ref = jffs2_first_valid_node(ref->next_in_ino); 1008 spin_unlock(&c->erase_completion_lock); 1009 1010 cond_resched(); 1011 1012 /* 1013 * At this point we don't know the type of the node we're going 1014 * to read, so we do not know the size of its header. In order 1015 * to minimize the amount of flash IO we assume the header is 1016 * of size = JFFS2_MIN_NODE_HEADER. 1017 */ 1018 len = JFFS2_MIN_NODE_HEADER; 1019 if (jffs2_is_writebuffered(c)) { 1020 int end, rem; 1021 1022 /* 1023 * We are about to read JFFS2_MIN_NODE_HEADER bytes, 1024 * but this flash has some minimal I/O unit. It is 1025 * possible that we'll need to read more soon, so read 1026 * up to the next min. I/O unit, in order not to 1027 * re-read the same min. I/O unit twice. 1028 */ 1029 end = ref_offset(ref) + len; 1030 rem = end % c->wbuf_pagesize; 1031 if (rem) 1032 end += c->wbuf_pagesize - rem; 1033 len = end - ref_offset(ref); 1034 } 1035 1036 dbg_readinode("read %d bytes at %#08x(%d).\n", len, ref_offset(ref), ref_flags(ref)); 1037 1038 err = jffs2_flash_read(c, ref_offset(ref), len, &retlen, buf); 1039 if (err) { 1040 JFFS2_ERROR("can not read %d bytes from 0x%08x, " "error code: %d.\n", len, ref_offset(ref), err); 1041 goto free_out; 1042 } 1043 1044 if (retlen < len) { 1045 JFFS2_ERROR("short read at %#08x: %zu instead of %d.\n", ref_offset(ref), retlen, len); 1046 err = -EIO; 1047 goto free_out; 1048 } 1049 1050 node = (union jffs2_node_union *)buf; 1051 1052 /* No need to mask in the valid bit; it shouldn't be invalid */ 1053 if (je32_to_cpu(node->u.hdr_crc) != crc32(0, node, sizeof(node->u)-4)) { 1054 JFFS2_NOTICE("Node header CRC failed at %#08x. {%04x,%04x,%08x,%08x}\n", 1055 ref_offset(ref), je16_to_cpu(node->u.magic), 1056 je16_to_cpu(node->u.nodetype), 1057 je32_to_cpu(node->u.totlen), 1058 je32_to_cpu(node->u.hdr_crc)); 1059 jffs2_dbg_dump_node(c, ref_offset(ref)); 1060 jffs2_mark_node_obsolete(c, ref); 1061 goto cont; 1062 } 1063 if (je16_to_cpu(node->u.magic) != JFFS2_MAGIC_BITMASK) { 1064 /* Not a JFFS2 node, whinge and move on */ 1065 JFFS2_NOTICE("Wrong magic bitmask 0x%04x in node header at %#08x.\n", 1066 je16_to_cpu(node->u.magic), ref_offset(ref)); 1067 jffs2_mark_node_obsolete(c, ref); 1068 goto cont; 1069 } 1070 1071 switch (je16_to_cpu(node->u.nodetype)) { 1072 1073 case JFFS2_NODETYPE_DIRENT: 1074 1075 if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_raw_dirent) && 1076 len < sizeof(struct jffs2_raw_dirent)) { 1077 err = read_more(c, ref, sizeof(struct jffs2_raw_dirent), &len, buf); 1078 if (unlikely(err)) 1079 goto free_out; 1080 } 1081 1082 err = read_direntry(c, ref, &node->d, retlen, rii); 1083 if (unlikely(err)) 1084 goto free_out; 1085 1086 break; 1087 1088 case JFFS2_NODETYPE_INODE: 1089 1090 if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_raw_inode) && 1091 len < sizeof(struct jffs2_raw_inode)) { 1092 err = read_more(c, ref, sizeof(struct jffs2_raw_inode), &len, buf); 1093 if (unlikely(err)) 1094 goto free_out; 1095 } 1096 1097 err = read_dnode(c, ref, &node->i, len, rii); 1098 if (unlikely(err)) 1099 goto free_out; 1100 1101 break; 1102 1103 default: 1104 if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_unknown_node) && 1105 len < sizeof(struct jffs2_unknown_node)) { 1106 err = read_more(c, ref, sizeof(struct jffs2_unknown_node), &len, buf); 1107 if (unlikely(err)) 1108 goto free_out; 1109 } 1110 1111 err = read_unknown(c, ref, &node->u); 1112 if (unlikely(err)) 1113 goto free_out; 1114 1115 } 1116 cont: 1117 spin_lock(&c->erase_completion_lock); 1118 } 1119 1120 spin_unlock(&c->erase_completion_lock); 1121 kfree(buf); 1122 1123 f->highest_version = rii->highest_version; 1124 1125 dbg_readinode("nodes of inode #%u were read, the highest version is %u, latest_mctime %u, mctime_ver %u.\n", 1126 f->inocache->ino, rii->highest_version, rii->latest_mctime, 1127 rii->mctime_ver); 1128 return 0; 1129 1130 free_out: 1131 jffs2_free_tmp_dnode_info_list(&rii->tn_root); 1132 jffs2_free_full_dirent_list(rii->fds); 1133 rii->fds = NULL; 1134 kfree(buf); 1135 return err; 1136} 1137 1138static int jffs2_do_read_inode_internal(struct jffs2_sb_info *c, 1139 struct jffs2_inode_info *f, 1140 struct jffs2_raw_inode *latest_node) 1141{ 1142 struct jffs2_readinode_info rii; 1143 uint32_t crc, new_size; 1144 size_t retlen; 1145 int ret; 1146 1147 dbg_readinode("ino #%u pino/nlink is %d\n", f->inocache->ino, 1148 f->inocache->pino_nlink); 1149 1150 memset(&rii, 0, sizeof(rii)); 1151 1152 /* Grab all nodes relevant to this ino */ 1153 ret = jffs2_get_inode_nodes(c, f, &rii); 1154 1155 if (ret) { 1156 JFFS2_ERROR("cannot read nodes for ino %u, returned error is %d\n", f->inocache->ino, ret); 1157 if (f->inocache->state == INO_STATE_READING) 1158 jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT); 1159 return ret; 1160 } 1161 1162 ret = jffs2_build_inode_fragtree(c, f, &rii); 1163 if (ret) { 1164 JFFS2_ERROR("Failed to build final fragtree for inode #%u: error %d\n", 1165 f->inocache->ino, ret); 1166 if (f->inocache->state == INO_STATE_READING) 1167 jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT); 1168 jffs2_free_tmp_dnode_info_list(&rii.tn_root); 1169 if (rii.mdata_tn) { 1170 jffs2_free_full_dnode(rii.mdata_tn->fn); 1171 jffs2_free_tmp_dnode_info(rii.mdata_tn); 1172 rii.mdata_tn = NULL; 1173 } 1174 return ret; 1175 } 1176 1177 if (rii.mdata_tn) { 1178 if (rii.mdata_tn->fn->raw == rii.latest_ref) { 1179 f->metadata = rii.mdata_tn->fn; 1180 jffs2_free_tmp_dnode_info(rii.mdata_tn); 1181 } else { 1182 jffs2_kill_tn(c, rii.mdata_tn); 1183 } 1184 rii.mdata_tn = NULL; 1185 } 1186 1187 f->dents = rii.fds; 1188 1189 jffs2_dbg_fragtree_paranoia_check_nolock(f); 1190 1191 if (unlikely(!rii.latest_ref)) { 1192 /* No data nodes for this inode. */ 1193 if (f->inocache->ino != 1) { 1194 JFFS2_WARNING("no data nodes found for ino #%u\n", f->inocache->ino); 1195 if (!rii.fds) { 1196 if (f->inocache->state == INO_STATE_READING) 1197 jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT); 1198 return -EIO; 1199 } 1200 JFFS2_NOTICE("but it has children so we fake some modes for it\n"); 1201 } 1202 latest_node->mode = cpu_to_jemode(S_IFDIR|S_IRUGO|S_IWUSR|S_IXUGO); 1203 latest_node->version = cpu_to_je32(0); 1204 latest_node->atime = latest_node->ctime = latest_node->mtime = cpu_to_je32(0); 1205 latest_node->isize = cpu_to_je32(0); 1206 latest_node->gid = cpu_to_je16(0); 1207 latest_node->uid = cpu_to_je16(0); 1208 if (f->inocache->state == INO_STATE_READING) 1209 jffs2_set_inocache_state(c, f->inocache, INO_STATE_PRESENT); 1210 return 0; 1211 } 1212 1213 ret = jffs2_flash_read(c, ref_offset(rii.latest_ref), sizeof(*latest_node), &retlen, (void *)latest_node); 1214 if (ret || retlen != sizeof(*latest_node)) { 1215 JFFS2_ERROR("failed to read from flash: error %d, %zd of %zd bytes read\n", 1216 ret, retlen, sizeof(*latest_node)); 1217 mutex_unlock(&f->sem); 1218 jffs2_do_clear_inode(c, f); 1219 return ret?ret:-EIO; 1220 } 1221 1222 crc = crc32(0, latest_node, sizeof(*latest_node)-8); 1223 if (crc != je32_to_cpu(latest_node->node_crc)) { 1224 JFFS2_ERROR("CRC failed for read_inode of inode %u at physical location 0x%x\n", 1225 f->inocache->ino, ref_offset(rii.latest_ref)); 1226 mutex_unlock(&f->sem); 1227 jffs2_do_clear_inode(c, f); 1228 return -EIO; 1229 } 1230 1231 switch(jemode_to_cpu(latest_node->mode) & S_IFMT) { 1232 case S_IFDIR: 1233 if (rii.mctime_ver > je32_to_cpu(latest_node->version)) { 1234 /* The times in the latest_node are actually older than 1235 mctime in the latest dirent. Cheat. */ 1236 latest_node->ctime = latest_node->mtime = cpu_to_je32(rii.latest_mctime); 1237 } 1238 break; 1239 1240 1241 case S_IFREG: 1242 /* If it was a regular file, truncate it to the latest node's isize */ 1243 new_size = jffs2_truncate_fragtree(c, &f->fragtree, je32_to_cpu(latest_node->isize)); 1244 if (new_size != je32_to_cpu(latest_node->isize)) { 1245 JFFS2_WARNING("Truncating ino #%u to %d bytes failed because it only had %d bytes to start with!\n", 1246 f->inocache->ino, je32_to_cpu(latest_node->isize), new_size); 1247 latest_node->isize = cpu_to_je32(new_size); 1248 } 1249 break; 1250 1251 case S_IFLNK: 1252 if (!je32_to_cpu(latest_node->isize)) 1253 latest_node->isize = latest_node->dsize; 1254 1255 if (f->inocache->state != INO_STATE_CHECKING) { 1256 /* Symlink's inode data is the target path. Read it and 1257 * keep in RAM to facilitate quick follow symlink 1258 * operation. */ 1259 f->target = kmalloc(je32_to_cpu(latest_node->csize) + 1, GFP_KERNEL); 1260 if (!f->target) { 1261 JFFS2_ERROR("can't allocate %d bytes of memory for the symlink target path cache\n", je32_to_cpu(latest_node->csize)); 1262 mutex_unlock(&f->sem); 1263 jffs2_do_clear_inode(c, f); 1264 return -ENOMEM; 1265 } 1266 1267 ret = jffs2_flash_read(c, ref_offset(rii.latest_ref) + sizeof(*latest_node), 1268 je32_to_cpu(latest_node->csize), &retlen, (char *)f->target); 1269 1270 if (ret || retlen != je32_to_cpu(latest_node->csize)) { 1271 if (retlen != je32_to_cpu(latest_node->csize)) 1272 ret = -EIO; 1273 kfree(f->target); 1274 f->target = NULL; 1275 mutex_unlock(&f->sem); 1276 jffs2_do_clear_inode(c, f); 1277 return ret; 1278 } 1279 1280 f->target[je32_to_cpu(latest_node->csize)] = '\0'; 1281 dbg_readinode("symlink's target '%s' cached\n", f->target); 1282 } 1283 1284 /* fall through... */ 1285 1286 case S_IFBLK: 1287 case S_IFCHR: 1288 /* Certain inode types should have only one data node, and it's 1289 kept as the metadata node */ 1290 if (f->metadata) { 1291 JFFS2_ERROR("Argh. Special inode #%u with mode 0%o had metadata node\n", 1292 f->inocache->ino, jemode_to_cpu(latest_node->mode)); 1293 mutex_unlock(&f->sem); 1294 jffs2_do_clear_inode(c, f); 1295 return -EIO; 1296 } 1297 if (!frag_first(&f->fragtree)) { 1298 JFFS2_ERROR("Argh. Special inode #%u with mode 0%o has no fragments\n", 1299 f->inocache->ino, jemode_to_cpu(latest_node->mode)); 1300 mutex_unlock(&f->sem); 1301 jffs2_do_clear_inode(c, f); 1302 return -EIO; 1303 } 1304 /* ASSERT: f->fraglist != NULL */ 1305 if (frag_next(frag_first(&f->fragtree))) { 1306 JFFS2_ERROR("Argh. Special inode #%u with mode 0x%x had more than one node\n", 1307 f->inocache->ino, jemode_to_cpu(latest_node->mode)); 1308 mutex_unlock(&f->sem); 1309 jffs2_do_clear_inode(c, f); 1310 return -EIO; 1311 } 1312 /* OK. We're happy */ 1313 f->metadata = frag_first(&f->fragtree)->node; 1314 jffs2_free_node_frag(frag_first(&f->fragtree)); 1315 f->fragtree = RB_ROOT; 1316 break; 1317 } 1318 if (f->inocache->state == INO_STATE_READING) 1319 jffs2_set_inocache_state(c, f->inocache, INO_STATE_PRESENT); 1320 1321 return 0; 1322} 1323 1324/* Scan the list of all nodes present for this ino, build map of versions, etc. */ 1325int jffs2_do_read_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 1326 uint32_t ino, struct jffs2_raw_inode *latest_node) 1327{ 1328 dbg_readinode("read inode #%u\n", ino); 1329 1330 retry_inocache: 1331 spin_lock(&c->inocache_lock); 1332 f->inocache = jffs2_get_ino_cache(c, ino); 1333 1334 if (f->inocache) { 1335 /* Check its state. We may need to wait before we can use it */ 1336 switch(f->inocache->state) { 1337 case INO_STATE_UNCHECKED: 1338 case INO_STATE_CHECKEDABSENT: 1339 f->inocache->state = INO_STATE_READING; 1340 break; 1341 1342 case INO_STATE_CHECKING: 1343 case INO_STATE_GC: 1344 /* If it's in either of these states, we need 1345 to wait for whoever's got it to finish and 1346 put it back. */ 1347 dbg_readinode("waiting for ino #%u in state %d\n", ino, f->inocache->state); 1348 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock); 1349 goto retry_inocache; 1350 1351 case INO_STATE_READING: 1352 case INO_STATE_PRESENT: 1353 /* Eep. This should never happen. It can 1354 happen if Linux calls read_inode() again 1355 before clear_inode() has finished though. */ 1356 JFFS2_ERROR("Eep. Trying to read_inode #%u when it's already in state %d!\n", ino, f->inocache->state); 1357 /* Fail. That's probably better than allowing it to succeed */ 1358 f->inocache = NULL; 1359 break; 1360 1361 default: 1362 BUG(); 1363 } 1364 } 1365 spin_unlock(&c->inocache_lock); 1366 1367 if (!f->inocache && ino == 1) { 1368 /* Special case - no root inode on medium */ 1369 f->inocache = jffs2_alloc_inode_cache(); 1370 if (!f->inocache) { 1371 JFFS2_ERROR("cannot allocate inocache for root inode\n"); 1372 return -ENOMEM; 1373 } 1374 dbg_readinode("creating inocache for root inode\n"); 1375 memset(f->inocache, 0, sizeof(struct jffs2_inode_cache)); 1376 f->inocache->ino = f->inocache->pino_nlink = 1; 1377 f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache; 1378 f->inocache->state = INO_STATE_READING; 1379 jffs2_add_ino_cache(c, f->inocache); 1380 } 1381 if (!f->inocache) { 1382 JFFS2_ERROR("requestied to read an nonexistent ino %u\n", ino); 1383 return -ENOENT; 1384 } 1385 1386 return jffs2_do_read_inode_internal(c, f, latest_node); 1387} 1388 1389int jffs2_do_crccheck_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic) 1390{ 1391 struct jffs2_raw_inode n; 1392 struct jffs2_inode_info *f = kzalloc(sizeof(*f), GFP_KERNEL); 1393 int ret; 1394 1395 if (!f) 1396 return -ENOMEM; 1397 1398 mutex_init(&f->sem); 1399 mutex_lock(&f->sem); 1400 f->inocache = ic; 1401 1402 ret = jffs2_do_read_inode_internal(c, f, &n); 1403 if (!ret) { 1404 mutex_unlock(&f->sem); 1405 jffs2_do_clear_inode(c, f); 1406 } 1407 kfree (f); 1408 return ret; 1409} 1410 1411void jffs2_do_clear_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f) 1412{ 1413 struct jffs2_full_dirent *fd, *fds; 1414 int deleted; 1415 1416 jffs2_xattr_delete_inode(c, f->inocache); 1417 mutex_lock(&f->sem); 1418 deleted = f->inocache && !f->inocache->pino_nlink; 1419 1420 if (f->inocache && f->inocache->state != INO_STATE_CHECKING) 1421 jffs2_set_inocache_state(c, f->inocache, INO_STATE_CLEARING); 1422 1423 if (f->metadata) { 1424 if (deleted) 1425 jffs2_mark_node_obsolete(c, f->metadata->raw); 1426 jffs2_free_full_dnode(f->metadata); 1427 } 1428 1429 jffs2_kill_fragtree(&f->fragtree, deleted?c:NULL); 1430 1431 if (f->target) { 1432 kfree(f->target); 1433 f->target = NULL; 1434 } 1435 1436 fds = f->dents; 1437 while(fds) { 1438 fd = fds; 1439 fds = fd->next; 1440 jffs2_free_full_dirent(fd); 1441 } 1442 1443 if (f->inocache && f->inocache->state != INO_STATE_CHECKING) { 1444 jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT); 1445 if (f->inocache->nodes == (void *)f->inocache) 1446 jffs2_del_ino_cache(c, f->inocache); 1447 } 1448 1449 mutex_unlock(&f->sem); 1450} 1451