1 /* 2 * JFFS2 -- Journalling Flash File System, Version 2. 3 * 4 * Copyright (C) 2001-2003 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 * $Id: fs.c,v 1.52 2005/02/09 09:17:40 pavlov Exp $ 11 * 12 */ 13 14 #include <linux/version.h> 15 #include <linux/config.h> 16 #include <linux/kernel.h> 17 #include <linux/sched.h> 18 #include <linux/fs.h> 19 #include <linux/list.h> 20 #include <linux/mtd/mtd.h> 21 #include <linux/pagemap.h> 22 #include <linux/slab.h> 23 #include <linux/vmalloc.h> 24 #include <linux/vfs.h> 25 #include <linux/crc32.h> 26 #include "nodelist.h" 27 28 static int jffs2_flash_setup(struct jffs2_sb_info *c); 29 30 static int jffs2_do_setattr (struct inode *inode, struct iattr *iattr) 31 { 32 struct jffs2_full_dnode *old_metadata, *new_metadata; 33 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode); 34 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb); 35 struct jffs2_raw_inode *ri; 36 unsigned short dev; 37 unsigned char *mdata = NULL; 38 int mdatalen = 0; 39 unsigned int ivalid; 40 uint32_t phys_ofs, alloclen; 41 int ret; 42 D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino)); 43 ret = inode_change_ok(inode, iattr); 44 if (ret) 45 return ret; 46 47 /* Special cases - we don't want more than one data node 48 for these types on the medium at any time. So setattr 49 must read the original data associated with the node 50 (i.e. the device numbers or the target name) and write 51 it out again with the appropriate data attached */ 52 if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) { 53 /* For these, we don't actually need to read the old node */ 54 dev = old_encode_dev(inode->i_rdev); 55 mdata = (char *)&dev; 56 mdatalen = sizeof(dev); 57 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen)); 58 } else if (S_ISLNK(inode->i_mode)) { 59 mdatalen = f->metadata->size; 60 mdata = kmalloc(f->metadata->size, GFP_USER); 61 if (!mdata) 62 return -ENOMEM; 63 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen); 64 if (ret) { 65 kfree(mdata); 66 return ret; 67 } 68 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen)); 69 } 70 71 ri = jffs2_alloc_raw_inode(); 72 if (!ri) { 73 if (S_ISLNK(inode->i_mode)) 74 kfree(mdata); 75 return -ENOMEM; 76 } 77 78 ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &phys_ofs, &alloclen, ALLOC_NORMAL); 79 if (ret) { 80 jffs2_free_raw_inode(ri); 81 if (S_ISLNK(inode->i_mode & S_IFMT)) 82 kfree(mdata); 83 return ret; 84 } 85 down(&f->sem); 86 ivalid = iattr->ia_valid; 87 88 ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 89 ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE); 90 ri->totlen = cpu_to_je32(sizeof(*ri) + mdatalen); 91 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 92 93 ri->ino = cpu_to_je32(inode->i_ino); 94 ri->version = cpu_to_je32(++f->highest_version); 95 96 ri->uid = cpu_to_je16((ivalid & ATTR_UID)?iattr->ia_uid:inode->i_uid); 97 ri->gid = cpu_to_je16((ivalid & ATTR_GID)?iattr->ia_gid:inode->i_gid); 98 99 if (ivalid & ATTR_MODE) 100 if (iattr->ia_mode & S_ISGID && 101 !in_group_p(je16_to_cpu(ri->gid)) && !capable(CAP_FSETID)) 102 ri->mode = cpu_to_jemode(iattr->ia_mode & ~S_ISGID); 103 else 104 ri->mode = cpu_to_jemode(iattr->ia_mode); 105 else 106 ri->mode = cpu_to_jemode(inode->i_mode); 107 108 109 ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size); 110 ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime)); 111 ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime)); 112 ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime)); 113 114 ri->offset = cpu_to_je32(0); 115 ri->csize = ri->dsize = cpu_to_je32(mdatalen); 116 ri->compr = JFFS2_COMPR_NONE; 117 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) { 118 /* It's an extension. Make it a hole node */ 119 ri->compr = JFFS2_COMPR_ZERO; 120 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size); 121 ri->offset = cpu_to_je32(inode->i_size); 122 } 123 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 124 if (mdatalen) 125 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen)); 126 else 127 ri->data_crc = cpu_to_je32(0); 128 129 new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, phys_ofs, ALLOC_NORMAL); 130 if (S_ISLNK(inode->i_mode)) 131 kfree(mdata); 132 133 if (IS_ERR(new_metadata)) { 134 jffs2_complete_reservation(c); 135 jffs2_free_raw_inode(ri); 136 up(&f->sem); 137 return PTR_ERR(new_metadata); 138 } 139 /* It worked. Update the inode */ 140 inode->i_atime = ITIME(je32_to_cpu(ri->atime)); 141 inode->i_ctime = ITIME(je32_to_cpu(ri->ctime)); 142 inode->i_mtime = ITIME(je32_to_cpu(ri->mtime)); 143 inode->i_mode = jemode_to_cpu(ri->mode); 144 inode->i_uid = je16_to_cpu(ri->uid); 145 inode->i_gid = je16_to_cpu(ri->gid); 146 147 148 old_metadata = f->metadata; 149 150 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size) 151 jffs2_truncate_fraglist (c, &f->fragtree, iattr->ia_size); 152 153 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) { 154 jffs2_add_full_dnode_to_inode(c, f, new_metadata); 155 inode->i_size = iattr->ia_size; 156 f->metadata = NULL; 157 } else { 158 f->metadata = new_metadata; 159 } 160 if (old_metadata) { 161 jffs2_mark_node_obsolete(c, old_metadata->raw); 162 jffs2_free_full_dnode(old_metadata); 163 } 164 jffs2_free_raw_inode(ri); 165 166 up(&f->sem); 167 jffs2_complete_reservation(c); 168 169 /* We have to do the vmtruncate() without f->sem held, since 170 some pages may be locked and waiting for it in readpage(). 171 We are protected from a simultaneous write() extending i_size 172 back past iattr->ia_size, because do_truncate() holds the 173 generic inode semaphore. */ 174 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size) 175 vmtruncate(inode, iattr->ia_size); 176 177 return 0; 178 } 179 180 int jffs2_setattr(struct dentry *dentry, struct iattr *iattr) 181 { 182 return jffs2_do_setattr(dentry->d_inode, iattr); 183 } 184 185 int jffs2_statfs(struct super_block *sb, struct kstatfs *buf) 186 { 187 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb); 188 unsigned long avail; 189 190 buf->f_type = JFFS2_SUPER_MAGIC; 191 buf->f_bsize = 1 << PAGE_SHIFT; 192 buf->f_blocks = c->flash_size >> PAGE_SHIFT; 193 buf->f_files = 0; 194 buf->f_ffree = 0; 195 buf->f_namelen = JFFS2_MAX_NAME_LEN; 196 197 spin_lock(&c->erase_completion_lock); 198 199 avail = c->dirty_size + c->free_size; 200 if (avail > c->sector_size * c->resv_blocks_write) 201 avail -= c->sector_size * c->resv_blocks_write; 202 else 203 avail = 0; 204 205 buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT; 206 207 D2(jffs2_dump_block_lists(c)); 208 209 spin_unlock(&c->erase_completion_lock); 210 211 return 0; 212 } 213 214 215 void jffs2_clear_inode (struct inode *inode) 216 { 217 /* We can forget about this inode for now - drop all 218 * the nodelists associated with it, etc. 219 */ 220 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb); 221 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode); 222 223 D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode)); 224 225 jffs2_do_clear_inode(c, f); 226 } 227 228 void jffs2_read_inode (struct inode *inode) 229 { 230 struct jffs2_inode_info *f; 231 struct jffs2_sb_info *c; 232 struct jffs2_raw_inode latest_node; 233 int ret; 234 235 D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino)); 236 237 f = JFFS2_INODE_INFO(inode); 238 c = JFFS2_SB_INFO(inode->i_sb); 239 240 jffs2_init_inode_info(f); 241 242 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node); 243 244 if (ret) { 245 make_bad_inode(inode); 246 up(&f->sem); 247 return; 248 } 249 inode->i_mode = jemode_to_cpu(latest_node.mode); 250 inode->i_uid = je16_to_cpu(latest_node.uid); 251 inode->i_gid = je16_to_cpu(latest_node.gid); 252 inode->i_size = je32_to_cpu(latest_node.isize); 253 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime)); 254 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime)); 255 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime)); 256 257 inode->i_nlink = f->inocache->nlink; 258 259 inode->i_blksize = PAGE_SIZE; 260 inode->i_blocks = (inode->i_size + 511) >> 9; 261 262 switch (inode->i_mode & S_IFMT) { 263 jint16_t rdev; 264 265 case S_IFLNK: 266 inode->i_op = &jffs2_symlink_inode_operations; 267 break; 268 269 case S_IFDIR: 270 { 271 struct jffs2_full_dirent *fd; 272 273 for (fd=f->dents; fd; fd = fd->next) { 274 if (fd->type == DT_DIR && fd->ino) 275 inode->i_nlink++; 276 } 277 /* and '..' */ 278 inode->i_nlink++; 279 /* Root dir gets i_nlink 3 for some reason */ 280 if (inode->i_ino == 1) 281 inode->i_nlink++; 282 283 inode->i_op = &jffs2_dir_inode_operations; 284 inode->i_fop = &jffs2_dir_operations; 285 break; 286 } 287 case S_IFREG: 288 inode->i_op = &jffs2_file_inode_operations; 289 inode->i_fop = &jffs2_file_operations; 290 inode->i_mapping->a_ops = &jffs2_file_address_operations; 291 inode->i_mapping->nrpages = 0; 292 break; 293 294 case S_IFBLK: 295 case S_IFCHR: 296 /* Read the device numbers from the media */ 297 D1(printk(KERN_DEBUG "Reading device numbers from flash\n")); 298 if (jffs2_read_dnode(c, f, f->metadata, (char *)&rdev, 0, sizeof(rdev)) < 0) { 299 /* Eep */ 300 printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino); 301 up(&f->sem); 302 jffs2_do_clear_inode(c, f); 303 make_bad_inode(inode); 304 return; 305 } 306 307 case S_IFSOCK: 308 case S_IFIFO: 309 inode->i_op = &jffs2_file_inode_operations; 310 init_special_inode(inode, inode->i_mode, 311 old_decode_dev((je16_to_cpu(rdev)))); 312 break; 313 314 default: 315 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino); 316 } 317 318 up(&f->sem); 319 320 D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n")); 321 } 322 323 void jffs2_dirty_inode(struct inode *inode) 324 { 325 struct iattr iattr; 326 327 if (!(inode->i_state & I_DIRTY_DATASYNC)) { 328 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino)); 329 return; 330 } 331 332 D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino)); 333 334 iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME; 335 iattr.ia_mode = inode->i_mode; 336 iattr.ia_uid = inode->i_uid; 337 iattr.ia_gid = inode->i_gid; 338 iattr.ia_atime = inode->i_atime; 339 iattr.ia_mtime = inode->i_mtime; 340 iattr.ia_ctime = inode->i_ctime; 341 342 jffs2_do_setattr(inode, &iattr); 343 } 344 345 int jffs2_remount_fs (struct super_block *sb, int *flags, char *data) 346 { 347 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb); 348 349 if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY)) 350 return -EROFS; 351 352 /* We stop if it was running, then restart if it needs to. 353 This also catches the case where it was stopped and this 354 is just a remount to restart it. 355 Flush the writebuffer, if neccecary, else we loose it */ 356 if (!(sb->s_flags & MS_RDONLY)) { 357 jffs2_stop_garbage_collect_thread(c); 358 down(&c->alloc_sem); 359 jffs2_flush_wbuf_pad(c); 360 up(&c->alloc_sem); 361 } 362 363 if (!(*flags & MS_RDONLY)) 364 jffs2_start_garbage_collect_thread(c); 365 366 *flags |= MS_NOATIME; 367 368 return 0; 369 } 370 371 void jffs2_write_super (struct super_block *sb) 372 { 373 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb); 374 sb->s_dirt = 0; 375 376 if (sb->s_flags & MS_RDONLY) 377 return; 378 379 D1(printk(KERN_DEBUG "jffs2_write_super()\n")); 380 jffs2_garbage_collect_trigger(c); 381 jffs2_erase_pending_blocks(c, 0); 382 jffs2_flush_wbuf_gc(c, 0); 383 } 384 385 386 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash, 387 fill in the raw_inode while you're at it. */ 388 struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri) 389 { 390 struct inode *inode; 391 struct super_block *sb = dir_i->i_sb; 392 struct jffs2_sb_info *c; 393 struct jffs2_inode_info *f; 394 int ret; 395 396 D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode)); 397 398 c = JFFS2_SB_INFO(sb); 399 400 inode = new_inode(sb); 401 402 if (!inode) 403 return ERR_PTR(-ENOMEM); 404 405 f = JFFS2_INODE_INFO(inode); 406 jffs2_init_inode_info(f); 407 408 memset(ri, 0, sizeof(*ri)); 409 /* Set OS-specific defaults for new inodes */ 410 ri->uid = cpu_to_je16(current->fsuid); 411 412 if (dir_i->i_mode & S_ISGID) { 413 ri->gid = cpu_to_je16(dir_i->i_gid); 414 if (S_ISDIR(mode)) 415 mode |= S_ISGID; 416 } else { 417 ri->gid = cpu_to_je16(current->fsgid); 418 } 419 ri->mode = cpu_to_jemode(mode); 420 ret = jffs2_do_new_inode (c, f, mode, ri); 421 if (ret) { 422 make_bad_inode(inode); 423 iput(inode); 424 return ERR_PTR(ret); 425 } 426 inode->i_nlink = 1; 427 inode->i_ino = je32_to_cpu(ri->ino); 428 inode->i_mode = jemode_to_cpu(ri->mode); 429 inode->i_gid = je16_to_cpu(ri->gid); 430 inode->i_uid = je16_to_cpu(ri->uid); 431 inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC; 432 ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime)); 433 434 inode->i_blksize = PAGE_SIZE; 435 inode->i_blocks = 0; 436 inode->i_size = 0; 437 438 insert_inode_hash(inode); 439 440 return inode; 441 } 442 443 444 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent) 445 { 446 struct jffs2_sb_info *c; 447 struct inode *root_i; 448 int ret; 449 size_t blocks; 450 451 c = JFFS2_SB_INFO(sb); 452 453 #ifndef CONFIG_JFFS2_FS_NAND 454 if (c->mtd->type == MTD_NANDFLASH) { 455 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n"); 456 return -EINVAL; 457 } 458 #endif 459 #ifndef CONFIG_JFFS2_FS_DATAFLASH 460 if (c->mtd->type == MTD_DATAFLASH) { 461 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n"); 462 return -EINVAL; 463 } 464 #endif 465 466 c->flash_size = c->mtd->size; 467 468 /* 469 * Check, if we have to concatenate physical blocks to larger virtual blocks 470 * to reduce the memorysize for c->blocks. (kmalloc allows max. 128K allocation) 471 */ 472 c->sector_size = c->mtd->erasesize; 473 blocks = c->flash_size / c->sector_size; 474 if (!(c->mtd->flags & MTD_NO_VIRTBLOCKS)) { 475 while ((blocks * sizeof (struct jffs2_eraseblock)) > (128 * 1024)) { 476 blocks >>= 1; 477 c->sector_size <<= 1; 478 } 479 } 480 481 /* 482 * Size alignment check 483 */ 484 if ((c->sector_size * blocks) != c->flash_size) { 485 c->flash_size = c->sector_size * blocks; 486 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n", 487 c->flash_size / 1024); 488 } 489 490 if (c->sector_size != c->mtd->erasesize) 491 printk(KERN_INFO "jffs2: Erase block size too small (%dKiB). Using virtual blocks size (%dKiB) instead\n", 492 c->mtd->erasesize / 1024, c->sector_size / 1024); 493 494 if (c->flash_size < 5*c->sector_size) { 495 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size); 496 return -EINVAL; 497 } 498 499 c->cleanmarker_size = sizeof(struct jffs2_unknown_node); 500 /* Joern -- stick alignment for weird 8-byte-page flash here */ 501 502 /* NAND (or other bizarre) flash... do setup accordingly */ 503 ret = jffs2_flash_setup(c); 504 if (ret) 505 return ret; 506 507 c->inocache_list = kmalloc(INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *), GFP_KERNEL); 508 if (!c->inocache_list) { 509 ret = -ENOMEM; 510 goto out_wbuf; 511 } 512 memset(c->inocache_list, 0, INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *)); 513 514 if ((ret = jffs2_do_mount_fs(c))) 515 goto out_inohash; 516 517 ret = -EINVAL; 518 519 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n")); 520 root_i = iget(sb, 1); 521 if (is_bad_inode(root_i)) { 522 D1(printk(KERN_WARNING "get root inode failed\n")); 523 goto out_nodes; 524 } 525 526 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n")); 527 sb->s_root = d_alloc_root(root_i); 528 if (!sb->s_root) 529 goto out_root_i; 530 531 #if LINUX_VERSION_CODE >= 0x20403 532 sb->s_maxbytes = 0xFFFFFFFF; 533 #endif 534 sb->s_blocksize = PAGE_CACHE_SIZE; 535 sb->s_blocksize_bits = PAGE_CACHE_SHIFT; 536 sb->s_magic = JFFS2_SUPER_MAGIC; 537 if (!(sb->s_flags & MS_RDONLY)) 538 jffs2_start_garbage_collect_thread(c); 539 return 0; 540 541 out_root_i: 542 iput(root_i); 543 out_nodes: 544 jffs2_free_ino_caches(c); 545 jffs2_free_raw_node_refs(c); 546 if (c->mtd->flags & MTD_NO_VIRTBLOCKS) 547 vfree(c->blocks); 548 else 549 kfree(c->blocks); 550 out_inohash: 551 kfree(c->inocache_list); 552 out_wbuf: 553 jffs2_flash_cleanup(c); 554 555 return ret; 556 } 557 558 void jffs2_gc_release_inode(struct jffs2_sb_info *c, 559 struct jffs2_inode_info *f) 560 { 561 iput(OFNI_EDONI_2SFFJ(f)); 562 } 563 564 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c, 565 int inum, int nlink) 566 { 567 struct inode *inode; 568 struct jffs2_inode_cache *ic; 569 if (!nlink) { 570 /* The inode has zero nlink but its nodes weren't yet marked 571 obsolete. This has to be because we're still waiting for 572 the final (close() and) iput() to happen. 573 574 There's a possibility that the final iput() could have 575 happened while we were contemplating. In order to ensure 576 that we don't cause a new read_inode() (which would fail) 577 for the inode in question, we use ilookup() in this case 578 instead of iget(). 579 580 The nlink can't _become_ zero at this point because we're 581 holding the alloc_sem, and jffs2_do_unlink() would also 582 need that while decrementing nlink on any inode. 583 */ 584 inode = ilookup(OFNI_BS_2SFFJ(c), inum); 585 if (!inode) { 586 D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n", 587 inum)); 588 589 spin_lock(&c->inocache_lock); 590 ic = jffs2_get_ino_cache(c, inum); 591 if (!ic) { 592 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum)); 593 spin_unlock(&c->inocache_lock); 594 return NULL; 595 } 596 if (ic->state != INO_STATE_CHECKEDABSENT) { 597 /* Wait for progress. Don't just loop */ 598 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n", 599 ic->ino, ic->state)); 600 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock); 601 } else { 602 spin_unlock(&c->inocache_lock); 603 } 604 605 return NULL; 606 } 607 } else { 608 /* Inode has links to it still; they're not going away because 609 jffs2_do_unlink() would need the alloc_sem and we have it. 610 Just iget() it, and if read_inode() is necessary that's OK. 611 */ 612 inode = iget(OFNI_BS_2SFFJ(c), inum); 613 if (!inode) 614 return ERR_PTR(-ENOMEM); 615 } 616 if (is_bad_inode(inode)) { 617 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n", 618 inum, nlink); 619 /* NB. This will happen again. We need to do something appropriate here. */ 620 iput(inode); 621 return ERR_PTR(-EIO); 622 } 623 624 return JFFS2_INODE_INFO(inode); 625 } 626 627 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c, 628 struct jffs2_inode_info *f, 629 unsigned long offset, 630 unsigned long *priv) 631 { 632 struct inode *inode = OFNI_EDONI_2SFFJ(f); 633 struct page *pg; 634 635 pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT, 636 (void *)jffs2_do_readpage_unlock, inode); 637 if (IS_ERR(pg)) 638 return (void *)pg; 639 640 *priv = (unsigned long)pg; 641 return kmap(pg); 642 } 643 644 void jffs2_gc_release_page(struct jffs2_sb_info *c, 645 unsigned char *ptr, 646 unsigned long *priv) 647 { 648 struct page *pg = (void *)*priv; 649 650 kunmap(pg); 651 page_cache_release(pg); 652 } 653 654 static int jffs2_flash_setup(struct jffs2_sb_info *c) { 655 int ret = 0; 656 657 if (jffs2_cleanmarker_oob(c)) { 658 /* NAND flash... do setup accordingly */ 659 ret = jffs2_nand_flash_setup(c); 660 if (ret) 661 return ret; 662 } 663 664 /* add setups for other bizarre flashes here... */ 665 if (jffs2_nor_ecc(c)) { 666 ret = jffs2_nor_ecc_flash_setup(c); 667 if (ret) 668 return ret; 669 } 670 671 /* and Dataflash */ 672 if (jffs2_dataflash(c)) { 673 ret = jffs2_dataflash_setup(c); 674 if (ret) 675 return ret; 676 } 677 678 return ret; 679 } 680 681 void jffs2_flash_cleanup(struct jffs2_sb_info *c) { 682 683 if (jffs2_cleanmarker_oob(c)) { 684 jffs2_nand_flash_cleanup(c); 685 } 686 687 /* add cleanups for other bizarre flashes here... */ 688 if (jffs2_nor_ecc(c)) { 689 jffs2_nor_ecc_flash_cleanup(c); 690 } 691 692 /* and DataFlash */ 693 if (jffs2_dataflash(c)) { 694 jffs2_dataflash_cleanup(c); 695 } 696 } 697