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