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/capability.h> 13 #include <linux/kernel.h> 14 #include <linux/sched.h> 15 #include <linux/fs.h> 16 #include <linux/list.h> 17 #include <linux/mtd/mtd.h> 18 #include <linux/pagemap.h> 19 #include <linux/slab.h> 20 #include <linux/vmalloc.h> 21 #include <linux/vfs.h> 22 #include <linux/crc32.h> 23 #include "nodelist.h" 24 25 static int jffs2_flash_setup(struct jffs2_sb_info *c); 26 27 int jffs2_do_setattr (struct inode *inode, struct iattr *iattr) 28 { 29 struct jffs2_full_dnode *old_metadata, *new_metadata; 30 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode); 31 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb); 32 struct jffs2_raw_inode *ri; 33 union jffs2_device_node dev; 34 unsigned char *mdata = NULL; 35 int mdatalen = 0; 36 unsigned int ivalid; 37 uint32_t alloclen; 38 int ret; 39 40 D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino)); 41 42 /* Special cases - we don't want more than one data node 43 for these types on the medium at any time. So setattr 44 must read the original data associated with the node 45 (i.e. the device numbers or the target name) and write 46 it out again with the appropriate data attached */ 47 if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) { 48 /* For these, we don't actually need to read the old node */ 49 mdatalen = jffs2_encode_dev(&dev, inode->i_rdev); 50 mdata = (char *)&dev; 51 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen)); 52 } else if (S_ISLNK(inode->i_mode)) { 53 down(&f->sem); 54 mdatalen = f->metadata->size; 55 mdata = kmalloc(f->metadata->size, GFP_USER); 56 if (!mdata) { 57 up(&f->sem); 58 return -ENOMEM; 59 } 60 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen); 61 if (ret) { 62 up(&f->sem); 63 kfree(mdata); 64 return ret; 65 } 66 up(&f->sem); 67 D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen)); 68 } 69 70 ri = jffs2_alloc_raw_inode(); 71 if (!ri) { 72 if (S_ISLNK(inode->i_mode)) 73 kfree(mdata); 74 return -ENOMEM; 75 } 76 77 ret = jffs2_reserve_space(c, sizeof(*ri) + mdatalen, &alloclen, 78 ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE); 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, 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_fragtree (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 int rc; 183 184 rc = inode_change_ok(dentry->d_inode, iattr); 185 if (rc) 186 return rc; 187 188 rc = jffs2_do_setattr(dentry->d_inode, iattr); 189 if (!rc && (iattr->ia_valid & ATTR_MODE)) 190 rc = jffs2_acl_chmod(dentry->d_inode); 191 192 return rc; 193 } 194 195 int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf) 196 { 197 struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb); 198 unsigned long avail; 199 200 buf->f_type = JFFS2_SUPER_MAGIC; 201 buf->f_bsize = 1 << PAGE_SHIFT; 202 buf->f_blocks = c->flash_size >> PAGE_SHIFT; 203 buf->f_files = 0; 204 buf->f_ffree = 0; 205 buf->f_namelen = JFFS2_MAX_NAME_LEN; 206 207 spin_lock(&c->erase_completion_lock); 208 avail = c->dirty_size + c->free_size; 209 if (avail > c->sector_size * c->resv_blocks_write) 210 avail -= c->sector_size * c->resv_blocks_write; 211 else 212 avail = 0; 213 spin_unlock(&c->erase_completion_lock); 214 215 buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT; 216 217 return 0; 218 } 219 220 221 void jffs2_clear_inode (struct inode *inode) 222 { 223 /* We can forget about this inode for now - drop all 224 * the nodelists associated with it, etc. 225 */ 226 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb); 227 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode); 228 229 D1(printk(KERN_DEBUG "jffs2_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode)); 230 jffs2_do_clear_inode(c, f); 231 } 232 233 void jffs2_read_inode (struct inode *inode) 234 { 235 struct jffs2_inode_info *f; 236 struct jffs2_sb_info *c; 237 struct jffs2_raw_inode latest_node; 238 union jffs2_device_node jdev; 239 dev_t rdev = 0; 240 int ret; 241 242 D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino)); 243 244 f = JFFS2_INODE_INFO(inode); 245 c = JFFS2_SB_INFO(inode->i_sb); 246 247 jffs2_init_inode_info(f); 248 down(&f->sem); 249 250 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node); 251 252 if (ret) { 253 make_bad_inode(inode); 254 up(&f->sem); 255 return; 256 } 257 inode->i_mode = jemode_to_cpu(latest_node.mode); 258 inode->i_uid = je16_to_cpu(latest_node.uid); 259 inode->i_gid = je16_to_cpu(latest_node.gid); 260 inode->i_size = je32_to_cpu(latest_node.isize); 261 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime)); 262 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime)); 263 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime)); 264 265 inode->i_nlink = f->inocache->nlink; 266 267 inode->i_blocks = (inode->i_size + 511) >> 9; 268 269 switch (inode->i_mode & S_IFMT) { 270 271 case S_IFLNK: 272 inode->i_op = &jffs2_symlink_inode_operations; 273 break; 274 275 case S_IFDIR: 276 { 277 struct jffs2_full_dirent *fd; 278 279 for (fd=f->dents; fd; fd = fd->next) { 280 if (fd->type == DT_DIR && fd->ino) 281 inc_nlink(inode); 282 } 283 /* and '..' */ 284 inc_nlink(inode); 285 /* Root dir gets i_nlink 3 for some reason */ 286 if (inode->i_ino == 1) 287 inc_nlink(inode); 288 289 inode->i_op = &jffs2_dir_inode_operations; 290 inode->i_fop = &jffs2_dir_operations; 291 break; 292 } 293 case S_IFREG: 294 inode->i_op = &jffs2_file_inode_operations; 295 inode->i_fop = &jffs2_file_operations; 296 inode->i_mapping->a_ops = &jffs2_file_address_operations; 297 inode->i_mapping->nrpages = 0; 298 break; 299 300 case S_IFBLK: 301 case S_IFCHR: 302 /* Read the device numbers from the media */ 303 if (f->metadata->size != sizeof(jdev.old) && 304 f->metadata->size != sizeof(jdev.new)) { 305 printk(KERN_NOTICE "Device node has strange size %d\n", f->metadata->size); 306 up(&f->sem); 307 jffs2_do_clear_inode(c, f); 308 make_bad_inode(inode); 309 return; 310 } 311 D1(printk(KERN_DEBUG "Reading device numbers from flash\n")); 312 if (jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size) < 0) { 313 /* Eep */ 314 printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino); 315 up(&f->sem); 316 jffs2_do_clear_inode(c, f); 317 make_bad_inode(inode); 318 return; 319 } 320 if (f->metadata->size == sizeof(jdev.old)) 321 rdev = old_decode_dev(je16_to_cpu(jdev.old)); 322 else 323 rdev = new_decode_dev(je32_to_cpu(jdev.new)); 324 325 case S_IFSOCK: 326 case S_IFIFO: 327 inode->i_op = &jffs2_file_inode_operations; 328 init_special_inode(inode, inode->i_mode, rdev); 329 break; 330 331 default: 332 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino); 333 } 334 335 up(&f->sem); 336 337 D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n")); 338 } 339 340 void jffs2_dirty_inode(struct inode *inode) 341 { 342 struct iattr iattr; 343 344 if (!(inode->i_state & I_DIRTY_DATASYNC)) { 345 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino)); 346 return; 347 } 348 349 D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino)); 350 351 iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME; 352 iattr.ia_mode = inode->i_mode; 353 iattr.ia_uid = inode->i_uid; 354 iattr.ia_gid = inode->i_gid; 355 iattr.ia_atime = inode->i_atime; 356 iattr.ia_mtime = inode->i_mtime; 357 iattr.ia_ctime = inode->i_ctime; 358 359 jffs2_do_setattr(inode, &iattr); 360 } 361 362 int jffs2_remount_fs (struct super_block *sb, int *flags, char *data) 363 { 364 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb); 365 366 if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY)) 367 return -EROFS; 368 369 /* We stop if it was running, then restart if it needs to. 370 This also catches the case where it was stopped and this 371 is just a remount to restart it. 372 Flush the writebuffer, if neccecary, else we loose it */ 373 if (!(sb->s_flags & MS_RDONLY)) { 374 jffs2_stop_garbage_collect_thread(c); 375 down(&c->alloc_sem); 376 jffs2_flush_wbuf_pad(c); 377 up(&c->alloc_sem); 378 } 379 380 if (!(*flags & MS_RDONLY)) 381 jffs2_start_garbage_collect_thread(c); 382 383 *flags |= MS_NOATIME; 384 385 return 0; 386 } 387 388 void jffs2_write_super (struct super_block *sb) 389 { 390 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb); 391 sb->s_dirt = 0; 392 393 if (sb->s_flags & MS_RDONLY) 394 return; 395 396 D1(printk(KERN_DEBUG "jffs2_write_super()\n")); 397 jffs2_garbage_collect_trigger(c); 398 jffs2_erase_pending_blocks(c, 0); 399 jffs2_flush_wbuf_gc(c, 0); 400 } 401 402 403 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash, 404 fill in the raw_inode while you're at it. */ 405 struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri, 406 struct posix_acl **acl) 407 { 408 struct inode *inode; 409 struct super_block *sb = dir_i->i_sb; 410 struct jffs2_sb_info *c; 411 struct jffs2_inode_info *f; 412 int ret; 413 414 D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode)); 415 416 c = JFFS2_SB_INFO(sb); 417 418 inode = new_inode(sb); 419 420 if (!inode) 421 return ERR_PTR(-ENOMEM); 422 423 f = JFFS2_INODE_INFO(inode); 424 jffs2_init_inode_info(f); 425 down(&f->sem); 426 427 memset(ri, 0, sizeof(*ri)); 428 /* Set OS-specific defaults for new inodes */ 429 ri->uid = cpu_to_je16(current->fsuid); 430 431 if (dir_i->i_mode & S_ISGID) { 432 ri->gid = cpu_to_je16(dir_i->i_gid); 433 if (S_ISDIR(mode)) 434 mode |= S_ISGID; 435 } else { 436 ri->gid = cpu_to_je16(current->fsgid); 437 } 438 439 /* POSIX ACLs have to be processed now, at least partly. 440 The umask is only applied if there's no default ACL */ 441 if (!S_ISLNK(mode)) { 442 *acl = jffs2_get_acl(dir_i, ACL_TYPE_DEFAULT); 443 if (IS_ERR(*acl)) { 444 make_bad_inode(inode); 445 iput(inode); 446 inode = (void *)*acl; 447 *acl = NULL; 448 return inode; 449 } 450 if (!(*acl)) 451 mode &= ~current->fs->umask; 452 } else { 453 *acl = NULL; 454 } 455 ret = jffs2_do_new_inode (c, f, mode, ri); 456 if (ret) { 457 make_bad_inode(inode); 458 iput(inode); 459 return ERR_PTR(ret); 460 } 461 inode->i_nlink = 1; 462 inode->i_ino = je32_to_cpu(ri->ino); 463 inode->i_mode = jemode_to_cpu(ri->mode); 464 inode->i_gid = je16_to_cpu(ri->gid); 465 inode->i_uid = je16_to_cpu(ri->uid); 466 inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC; 467 ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime)); 468 469 inode->i_blocks = 0; 470 inode->i_size = 0; 471 472 insert_inode_hash(inode); 473 474 return inode; 475 } 476 477 478 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent) 479 { 480 struct jffs2_sb_info *c; 481 struct inode *root_i; 482 int ret; 483 size_t blocks; 484 485 c = JFFS2_SB_INFO(sb); 486 487 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER 488 if (c->mtd->type == MTD_NANDFLASH) { 489 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n"); 490 return -EINVAL; 491 } 492 if (c->mtd->type == MTD_DATAFLASH) { 493 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n"); 494 return -EINVAL; 495 } 496 #endif 497 498 c->flash_size = c->mtd->size; 499 c->sector_size = c->mtd->erasesize; 500 blocks = c->flash_size / c->sector_size; 501 502 /* 503 * Size alignment check 504 */ 505 if ((c->sector_size * blocks) != c->flash_size) { 506 c->flash_size = c->sector_size * blocks; 507 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n", 508 c->flash_size / 1024); 509 } 510 511 if (c->flash_size < 5*c->sector_size) { 512 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size); 513 return -EINVAL; 514 } 515 516 c->cleanmarker_size = sizeof(struct jffs2_unknown_node); 517 518 /* NAND (or other bizarre) flash... do setup accordingly */ 519 ret = jffs2_flash_setup(c); 520 if (ret) 521 return ret; 522 523 c->inocache_list = kcalloc(INOCACHE_HASHSIZE, sizeof(struct jffs2_inode_cache *), GFP_KERNEL); 524 if (!c->inocache_list) { 525 ret = -ENOMEM; 526 goto out_wbuf; 527 } 528 529 jffs2_init_xattr_subsystem(c); 530 531 if ((ret = jffs2_do_mount_fs(c))) 532 goto out_inohash; 533 534 ret = -EINVAL; 535 536 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n")); 537 root_i = iget(sb, 1); 538 if (is_bad_inode(root_i)) { 539 D1(printk(KERN_WARNING "get root inode failed\n")); 540 goto out_root_i; 541 } 542 543 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n")); 544 sb->s_root = d_alloc_root(root_i); 545 if (!sb->s_root) 546 goto out_root_i; 547 548 sb->s_maxbytes = 0xFFFFFFFF; 549 sb->s_blocksize = PAGE_CACHE_SIZE; 550 sb->s_blocksize_bits = PAGE_CACHE_SHIFT; 551 sb->s_magic = JFFS2_SUPER_MAGIC; 552 if (!(sb->s_flags & MS_RDONLY)) 553 jffs2_start_garbage_collect_thread(c); 554 return 0; 555 556 out_root_i: 557 iput(root_i); 558 jffs2_free_ino_caches(c); 559 jffs2_free_raw_node_refs(c); 560 if (jffs2_blocks_use_vmalloc(c)) 561 vfree(c->blocks); 562 else 563 kfree(c->blocks); 564 out_inohash: 565 jffs2_clear_xattr_subsystem(c); 566 kfree(c->inocache_list); 567 out_wbuf: 568 jffs2_flash_cleanup(c); 569 570 return ret; 571 } 572 573 void jffs2_gc_release_inode(struct jffs2_sb_info *c, 574 struct jffs2_inode_info *f) 575 { 576 iput(OFNI_EDONI_2SFFJ(f)); 577 } 578 579 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c, 580 int inum, int nlink) 581 { 582 struct inode *inode; 583 struct jffs2_inode_cache *ic; 584 if (!nlink) { 585 /* The inode has zero nlink but its nodes weren't yet marked 586 obsolete. This has to be because we're still waiting for 587 the final (close() and) iput() to happen. 588 589 There's a possibility that the final iput() could have 590 happened while we were contemplating. In order to ensure 591 that we don't cause a new read_inode() (which would fail) 592 for the inode in question, we use ilookup() in this case 593 instead of iget(). 594 595 The nlink can't _become_ zero at this point because we're 596 holding the alloc_sem, and jffs2_do_unlink() would also 597 need that while decrementing nlink on any inode. 598 */ 599 inode = ilookup(OFNI_BS_2SFFJ(c), inum); 600 if (!inode) { 601 D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n", 602 inum)); 603 604 spin_lock(&c->inocache_lock); 605 ic = jffs2_get_ino_cache(c, inum); 606 if (!ic) { 607 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum)); 608 spin_unlock(&c->inocache_lock); 609 return NULL; 610 } 611 if (ic->state != INO_STATE_CHECKEDABSENT) { 612 /* Wait for progress. Don't just loop */ 613 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n", 614 ic->ino, ic->state)); 615 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock); 616 } else { 617 spin_unlock(&c->inocache_lock); 618 } 619 620 return NULL; 621 } 622 } else { 623 /* Inode has links to it still; they're not going away because 624 jffs2_do_unlink() would need the alloc_sem and we have it. 625 Just iget() it, and if read_inode() is necessary that's OK. 626 */ 627 inode = iget(OFNI_BS_2SFFJ(c), inum); 628 if (!inode) 629 return ERR_PTR(-ENOMEM); 630 } 631 if (is_bad_inode(inode)) { 632 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n", 633 inum, nlink); 634 /* NB. This will happen again. We need to do something appropriate here. */ 635 iput(inode); 636 return ERR_PTR(-EIO); 637 } 638 639 return JFFS2_INODE_INFO(inode); 640 } 641 642 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c, 643 struct jffs2_inode_info *f, 644 unsigned long offset, 645 unsigned long *priv) 646 { 647 struct inode *inode = OFNI_EDONI_2SFFJ(f); 648 struct page *pg; 649 650 pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT, 651 (void *)jffs2_do_readpage_unlock, inode); 652 if (IS_ERR(pg)) 653 return (void *)pg; 654 655 *priv = (unsigned long)pg; 656 return kmap(pg); 657 } 658 659 void jffs2_gc_release_page(struct jffs2_sb_info *c, 660 unsigned char *ptr, 661 unsigned long *priv) 662 { 663 struct page *pg = (void *)*priv; 664 665 kunmap(pg); 666 page_cache_release(pg); 667 } 668 669 static int jffs2_flash_setup(struct jffs2_sb_info *c) { 670 int ret = 0; 671 672 if (jffs2_cleanmarker_oob(c)) { 673 /* NAND flash... do setup accordingly */ 674 ret = jffs2_nand_flash_setup(c); 675 if (ret) 676 return ret; 677 } 678 679 /* and Dataflash */ 680 if (jffs2_dataflash(c)) { 681 ret = jffs2_dataflash_setup(c); 682 if (ret) 683 return ret; 684 } 685 686 /* and Intel "Sibley" flash */ 687 if (jffs2_nor_wbuf_flash(c)) { 688 ret = jffs2_nor_wbuf_flash_setup(c); 689 if (ret) 690 return ret; 691 } 692 693 /* and an UBI volume */ 694 if (jffs2_ubivol(c)) { 695 ret = jffs2_ubivol_setup(c); 696 if (ret) 697 return ret; 698 } 699 700 return ret; 701 } 702 703 void jffs2_flash_cleanup(struct jffs2_sb_info *c) { 704 705 if (jffs2_cleanmarker_oob(c)) { 706 jffs2_nand_flash_cleanup(c); 707 } 708 709 /* and DataFlash */ 710 if (jffs2_dataflash(c)) { 711 jffs2_dataflash_cleanup(c); 712 } 713 714 /* and Intel "Sibley" flash */ 715 if (jffs2_nor_wbuf_flash(c)) { 716 jffs2_nor_wbuf_flash_cleanup(c); 717 } 718 719 /* and an UBI volume */ 720 if (jffs2_ubivol(c)) { 721 jffs2_ubivol_cleanup(c); 722 } 723 } 724