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