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 struct inode *jffs2_iget(struct super_block *sb, unsigned long ino) 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 struct inode *inode; 240 dev_t rdev = 0; 241 int ret; 242 243 D1(printk(KERN_DEBUG "jffs2_iget(): ino == %lu\n", ino)); 244 245 inode = iget_locked(sb, ino); 246 if (!inode) 247 return ERR_PTR(-ENOMEM); 248 if (!(inode->i_state & I_NEW)) 249 return inode; 250 251 f = JFFS2_INODE_INFO(inode); 252 c = JFFS2_SB_INFO(inode->i_sb); 253 254 jffs2_init_inode_info(f); 255 down(&f->sem); 256 257 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node); 258 259 if (ret) { 260 up(&f->sem); 261 iget_failed(inode); 262 return ERR_PTR(ret); 263 } 264 inode->i_mode = jemode_to_cpu(latest_node.mode); 265 inode->i_uid = je16_to_cpu(latest_node.uid); 266 inode->i_gid = je16_to_cpu(latest_node.gid); 267 inode->i_size = je32_to_cpu(latest_node.isize); 268 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime)); 269 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime)); 270 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime)); 271 272 inode->i_nlink = f->inocache->nlink; 273 274 inode->i_blocks = (inode->i_size + 511) >> 9; 275 276 switch (inode->i_mode & S_IFMT) { 277 278 case S_IFLNK: 279 inode->i_op = &jffs2_symlink_inode_operations; 280 break; 281 282 case S_IFDIR: 283 { 284 struct jffs2_full_dirent *fd; 285 286 for (fd=f->dents; fd; fd = fd->next) { 287 if (fd->type == DT_DIR && fd->ino) 288 inc_nlink(inode); 289 } 290 /* and '..' */ 291 inc_nlink(inode); 292 /* Root dir gets i_nlink 3 for some reason */ 293 if (inode->i_ino == 1) 294 inc_nlink(inode); 295 296 inode->i_op = &jffs2_dir_inode_operations; 297 inode->i_fop = &jffs2_dir_operations; 298 break; 299 } 300 case S_IFREG: 301 inode->i_op = &jffs2_file_inode_operations; 302 inode->i_fop = &jffs2_file_operations; 303 inode->i_mapping->a_ops = &jffs2_file_address_operations; 304 inode->i_mapping->nrpages = 0; 305 break; 306 307 case S_IFBLK: 308 case S_IFCHR: 309 /* Read the device numbers from the media */ 310 if (f->metadata->size != sizeof(jdev.old) && 311 f->metadata->size != sizeof(jdev.new)) { 312 printk(KERN_NOTICE "Device node has strange size %d\n", f->metadata->size); 313 goto error_io; 314 } 315 D1(printk(KERN_DEBUG "Reading device numbers from flash\n")); 316 ret = jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size); 317 if (ret < 0) { 318 /* Eep */ 319 printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino); 320 goto error; 321 } 322 if (f->metadata->size == sizeof(jdev.old)) 323 rdev = old_decode_dev(je16_to_cpu(jdev.old)); 324 else 325 rdev = new_decode_dev(je32_to_cpu(jdev.new)); 326 327 case S_IFSOCK: 328 case S_IFIFO: 329 inode->i_op = &jffs2_file_inode_operations; 330 init_special_inode(inode, inode->i_mode, rdev); 331 break; 332 333 default: 334 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino); 335 } 336 337 up(&f->sem); 338 339 D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n")); 340 unlock_new_inode(inode); 341 return inode; 342 343 error_io: 344 ret = -EIO; 345 error: 346 up(&f->sem); 347 jffs2_do_clear_inode(c, f); 348 iget_failed(inode); 349 return ERR_PTR(ret); 350 } 351 352 void jffs2_dirty_inode(struct inode *inode) 353 { 354 struct iattr iattr; 355 356 if (!(inode->i_state & I_DIRTY_DATASYNC)) { 357 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino)); 358 return; 359 } 360 361 D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino)); 362 363 iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME; 364 iattr.ia_mode = inode->i_mode; 365 iattr.ia_uid = inode->i_uid; 366 iattr.ia_gid = inode->i_gid; 367 iattr.ia_atime = inode->i_atime; 368 iattr.ia_mtime = inode->i_mtime; 369 iattr.ia_ctime = inode->i_ctime; 370 371 jffs2_do_setattr(inode, &iattr); 372 } 373 374 int jffs2_remount_fs (struct super_block *sb, int *flags, char *data) 375 { 376 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb); 377 378 if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY)) 379 return -EROFS; 380 381 /* We stop if it was running, then restart if it needs to. 382 This also catches the case where it was stopped and this 383 is just a remount to restart it. 384 Flush the writebuffer, if neccecary, else we loose it */ 385 if (!(sb->s_flags & MS_RDONLY)) { 386 jffs2_stop_garbage_collect_thread(c); 387 down(&c->alloc_sem); 388 jffs2_flush_wbuf_pad(c); 389 up(&c->alloc_sem); 390 } 391 392 if (!(*flags & MS_RDONLY)) 393 jffs2_start_garbage_collect_thread(c); 394 395 *flags |= MS_NOATIME; 396 397 return 0; 398 } 399 400 void jffs2_write_super (struct super_block *sb) 401 { 402 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb); 403 sb->s_dirt = 0; 404 405 if (sb->s_flags & MS_RDONLY) 406 return; 407 408 D1(printk(KERN_DEBUG "jffs2_write_super()\n")); 409 jffs2_garbage_collect_trigger(c); 410 jffs2_erase_pending_blocks(c, 0); 411 jffs2_flush_wbuf_gc(c, 0); 412 } 413 414 415 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash, 416 fill in the raw_inode while you're at it. */ 417 struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri) 418 { 419 struct inode *inode; 420 struct super_block *sb = dir_i->i_sb; 421 struct jffs2_sb_info *c; 422 struct jffs2_inode_info *f; 423 int ret; 424 425 D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode)); 426 427 c = JFFS2_SB_INFO(sb); 428 429 inode = new_inode(sb); 430 431 if (!inode) 432 return ERR_PTR(-ENOMEM); 433 434 f = JFFS2_INODE_INFO(inode); 435 jffs2_init_inode_info(f); 436 down(&f->sem); 437 438 memset(ri, 0, sizeof(*ri)); 439 /* Set OS-specific defaults for new inodes */ 440 ri->uid = cpu_to_je16(current->fsuid); 441 442 if (dir_i->i_mode & S_ISGID) { 443 ri->gid = cpu_to_je16(dir_i->i_gid); 444 if (S_ISDIR(mode)) 445 mode |= S_ISGID; 446 } else { 447 ri->gid = cpu_to_je16(current->fsgid); 448 } 449 450 /* POSIX ACLs have to be processed now, at least partly. 451 The umask is only applied if there's no default ACL */ 452 ret = jffs2_init_acl_pre(dir_i, inode, &mode); 453 if (ret) { 454 make_bad_inode(inode); 455 iput(inode); 456 return ERR_PTR(ret); 457 } 458 ret = jffs2_do_new_inode (c, f, mode, ri); 459 if (ret) { 460 make_bad_inode(inode); 461 iput(inode); 462 return ERR_PTR(ret); 463 } 464 inode->i_nlink = 1; 465 inode->i_ino = je32_to_cpu(ri->ino); 466 inode->i_mode = jemode_to_cpu(ri->mode); 467 inode->i_gid = je16_to_cpu(ri->gid); 468 inode->i_uid = je16_to_cpu(ri->uid); 469 inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC; 470 ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime)); 471 472 inode->i_blocks = 0; 473 inode->i_size = 0; 474 475 insert_inode_hash(inode); 476 477 return inode; 478 } 479 480 481 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent) 482 { 483 struct jffs2_sb_info *c; 484 struct inode *root_i; 485 int ret; 486 size_t blocks; 487 488 c = JFFS2_SB_INFO(sb); 489 490 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER 491 if (c->mtd->type == MTD_NANDFLASH) { 492 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n"); 493 return -EINVAL; 494 } 495 if (c->mtd->type == MTD_DATAFLASH) { 496 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n"); 497 return -EINVAL; 498 } 499 #endif 500 501 c->flash_size = c->mtd->size; 502 c->sector_size = c->mtd->erasesize; 503 blocks = c->flash_size / c->sector_size; 504 505 /* 506 * Size alignment check 507 */ 508 if ((c->sector_size * blocks) != c->flash_size) { 509 c->flash_size = c->sector_size * blocks; 510 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n", 511 c->flash_size / 1024); 512 } 513 514 if (c->flash_size < 5*c->sector_size) { 515 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size); 516 return -EINVAL; 517 } 518 519 c->cleanmarker_size = sizeof(struct jffs2_unknown_node); 520 521 /* NAND (or other bizarre) flash... do setup accordingly */ 522 ret = jffs2_flash_setup(c); 523 if (ret) 524 return ret; 525 526 c->inocache_list = kcalloc(INOCACHE_HASHSIZE, sizeof(struct jffs2_inode_cache *), GFP_KERNEL); 527 if (!c->inocache_list) { 528 ret = -ENOMEM; 529 goto out_wbuf; 530 } 531 532 jffs2_init_xattr_subsystem(c); 533 534 if ((ret = jffs2_do_mount_fs(c))) 535 goto out_inohash; 536 537 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n")); 538 root_i = jffs2_iget(sb, 1); 539 if (IS_ERR(root_i)) { 540 D1(printk(KERN_WARNING "get root inode failed\n")); 541 ret = PTR_ERR(root_i); 542 goto out_root; 543 } 544 545 ret = -ENOMEM; 546 547 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n")); 548 sb->s_root = d_alloc_root(root_i); 549 if (!sb->s_root) 550 goto out_root_i; 551 552 sb->s_maxbytes = 0xFFFFFFFF; 553 sb->s_blocksize = PAGE_CACHE_SIZE; 554 sb->s_blocksize_bits = PAGE_CACHE_SHIFT; 555 sb->s_magic = JFFS2_SUPER_MAGIC; 556 if (!(sb->s_flags & MS_RDONLY)) 557 jffs2_start_garbage_collect_thread(c); 558 return 0; 559 560 out_root_i: 561 iput(root_i); 562 out_root: 563 jffs2_free_ino_caches(c); 564 jffs2_free_raw_node_refs(c); 565 if (jffs2_blocks_use_vmalloc(c)) 566 vfree(c->blocks); 567 else 568 kfree(c->blocks); 569 out_inohash: 570 jffs2_clear_xattr_subsystem(c); 571 kfree(c->inocache_list); 572 out_wbuf: 573 jffs2_flash_cleanup(c); 574 575 return ret; 576 } 577 578 void jffs2_gc_release_inode(struct jffs2_sb_info *c, 579 struct jffs2_inode_info *f) 580 { 581 iput(OFNI_EDONI_2SFFJ(f)); 582 } 583 584 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c, 585 int inum, int nlink) 586 { 587 struct inode *inode; 588 struct jffs2_inode_cache *ic; 589 if (!nlink) { 590 /* The inode has zero nlink but its nodes weren't yet marked 591 obsolete. This has to be because we're still waiting for 592 the final (close() and) iput() to happen. 593 594 There's a possibility that the final iput() could have 595 happened while we were contemplating. In order to ensure 596 that we don't cause a new read_inode() (which would fail) 597 for the inode in question, we use ilookup() in this case 598 instead of iget(). 599 600 The nlink can't _become_ zero at this point because we're 601 holding the alloc_sem, and jffs2_do_unlink() would also 602 need that while decrementing nlink on any inode. 603 */ 604 inode = ilookup(OFNI_BS_2SFFJ(c), inum); 605 if (!inode) { 606 D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n", 607 inum)); 608 609 spin_lock(&c->inocache_lock); 610 ic = jffs2_get_ino_cache(c, inum); 611 if (!ic) { 612 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum)); 613 spin_unlock(&c->inocache_lock); 614 return NULL; 615 } 616 if (ic->state != INO_STATE_CHECKEDABSENT) { 617 /* Wait for progress. Don't just loop */ 618 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n", 619 ic->ino, ic->state)); 620 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock); 621 } else { 622 spin_unlock(&c->inocache_lock); 623 } 624 625 return NULL; 626 } 627 } else { 628 /* Inode has links to it still; they're not going away because 629 jffs2_do_unlink() would need the alloc_sem and we have it. 630 Just iget() it, and if read_inode() is necessary that's OK. 631 */ 632 inode = jffs2_iget(OFNI_BS_2SFFJ(c), inum); 633 if (IS_ERR(inode)) 634 return ERR_CAST(inode); 635 } 636 if (is_bad_inode(inode)) { 637 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n", 638 inum, nlink); 639 /* NB. This will happen again. We need to do something appropriate here. */ 640 iput(inode); 641 return ERR_PTR(-EIO); 642 } 643 644 return JFFS2_INODE_INFO(inode); 645 } 646 647 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c, 648 struct jffs2_inode_info *f, 649 unsigned long offset, 650 unsigned long *priv) 651 { 652 struct inode *inode = OFNI_EDONI_2SFFJ(f); 653 struct page *pg; 654 655 pg = read_cache_page_async(inode->i_mapping, offset >> PAGE_CACHE_SHIFT, 656 (void *)jffs2_do_readpage_unlock, inode); 657 if (IS_ERR(pg)) 658 return (void *)pg; 659 660 *priv = (unsigned long)pg; 661 return kmap(pg); 662 } 663 664 void jffs2_gc_release_page(struct jffs2_sb_info *c, 665 unsigned char *ptr, 666 unsigned long *priv) 667 { 668 struct page *pg = (void *)*priv; 669 670 kunmap(pg); 671 page_cache_release(pg); 672 } 673 674 static int jffs2_flash_setup(struct jffs2_sb_info *c) { 675 int ret = 0; 676 677 if (jffs2_cleanmarker_oob(c)) { 678 /* NAND flash... do setup accordingly */ 679 ret = jffs2_nand_flash_setup(c); 680 if (ret) 681 return ret; 682 } 683 684 /* and Dataflash */ 685 if (jffs2_dataflash(c)) { 686 ret = jffs2_dataflash_setup(c); 687 if (ret) 688 return ret; 689 } 690 691 /* and Intel "Sibley" flash */ 692 if (jffs2_nor_wbuf_flash(c)) { 693 ret = jffs2_nor_wbuf_flash_setup(c); 694 if (ret) 695 return ret; 696 } 697 698 /* and an UBI volume */ 699 if (jffs2_ubivol(c)) { 700 ret = jffs2_ubivol_setup(c); 701 if (ret) 702 return ret; 703 } 704 705 return ret; 706 } 707 708 void jffs2_flash_cleanup(struct jffs2_sb_info *c) { 709 710 if (jffs2_cleanmarker_oob(c)) { 711 jffs2_nand_flash_cleanup(c); 712 } 713 714 /* and DataFlash */ 715 if (jffs2_dataflash(c)) { 716 jffs2_dataflash_cleanup(c); 717 } 718 719 /* and Intel "Sibley" flash */ 720 if (jffs2_nor_wbuf_flash(c)) { 721 jffs2_nor_wbuf_flash_cleanup(c); 722 } 723 724 /* and an UBI volume */ 725 if (jffs2_ubivol(c)) { 726 jffs2_ubivol_cleanup(c); 727 } 728 } 729