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 vmtruncate() 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 vmtruncate(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_clear_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_clear_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode)); 238 jffs2_do_clear_inode(c, f); 239 } 240 241 struct inode *jffs2_iget(struct super_block *sb, unsigned long ino) 242 { 243 struct jffs2_inode_info *f; 244 struct jffs2_sb_info *c; 245 struct jffs2_raw_inode latest_node; 246 union jffs2_device_node jdev; 247 struct inode *inode; 248 dev_t rdev = 0; 249 int ret; 250 251 D1(printk(KERN_DEBUG "jffs2_iget(): ino == %lu\n", ino)); 252 253 inode = iget_locked(sb, ino); 254 if (!inode) 255 return ERR_PTR(-ENOMEM); 256 if (!(inode->i_state & I_NEW)) 257 return inode; 258 259 f = JFFS2_INODE_INFO(inode); 260 c = JFFS2_SB_INFO(inode->i_sb); 261 262 jffs2_init_inode_info(f); 263 mutex_lock(&f->sem); 264 265 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node); 266 267 if (ret) { 268 mutex_unlock(&f->sem); 269 iget_failed(inode); 270 return ERR_PTR(ret); 271 } 272 inode->i_mode = jemode_to_cpu(latest_node.mode); 273 inode->i_uid = je16_to_cpu(latest_node.uid); 274 inode->i_gid = je16_to_cpu(latest_node.gid); 275 inode->i_size = je32_to_cpu(latest_node.isize); 276 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime)); 277 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime)); 278 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime)); 279 280 inode->i_nlink = f->inocache->pino_nlink; 281 282 inode->i_blocks = (inode->i_size + 511) >> 9; 283 284 switch (inode->i_mode & S_IFMT) { 285 286 case S_IFLNK: 287 inode->i_op = &jffs2_symlink_inode_operations; 288 break; 289 290 case S_IFDIR: 291 { 292 struct jffs2_full_dirent *fd; 293 inode->i_nlink = 2; /* parent and '.' */ 294 295 for (fd=f->dents; fd; fd = fd->next) { 296 if (fd->type == DT_DIR && fd->ino) 297 inc_nlink(inode); 298 } 299 /* Root dir gets i_nlink 3 for some reason */ 300 if (inode->i_ino == 1) 301 inc_nlink(inode); 302 303 inode->i_op = &jffs2_dir_inode_operations; 304 inode->i_fop = &jffs2_dir_operations; 305 break; 306 } 307 case S_IFREG: 308 inode->i_op = &jffs2_file_inode_operations; 309 inode->i_fop = &jffs2_file_operations; 310 inode->i_mapping->a_ops = &jffs2_file_address_operations; 311 inode->i_mapping->nrpages = 0; 312 break; 313 314 case S_IFBLK: 315 case S_IFCHR: 316 /* Read the device numbers from the media */ 317 if (f->metadata->size != sizeof(jdev.old_id) && 318 f->metadata->size != sizeof(jdev.new_id)) { 319 printk(KERN_NOTICE "Device node has strange size %d\n", f->metadata->size); 320 goto error_io; 321 } 322 D1(printk(KERN_DEBUG "Reading device numbers from flash\n")); 323 ret = jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size); 324 if (ret < 0) { 325 /* Eep */ 326 printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino); 327 goto error; 328 } 329 if (f->metadata->size == sizeof(jdev.old_id)) 330 rdev = old_decode_dev(je16_to_cpu(jdev.old_id)); 331 else 332 rdev = new_decode_dev(je32_to_cpu(jdev.new_id)); 333 334 case S_IFSOCK: 335 case S_IFIFO: 336 inode->i_op = &jffs2_file_inode_operations; 337 init_special_inode(inode, inode->i_mode, rdev); 338 break; 339 340 default: 341 printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino); 342 } 343 344 mutex_unlock(&f->sem); 345 346 D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n")); 347 unlock_new_inode(inode); 348 return inode; 349 350 error_io: 351 ret = -EIO; 352 error: 353 mutex_unlock(&f->sem); 354 jffs2_do_clear_inode(c, f); 355 iget_failed(inode); 356 return ERR_PTR(ret); 357 } 358 359 void jffs2_dirty_inode(struct inode *inode) 360 { 361 struct iattr iattr; 362 363 if (!(inode->i_state & I_DIRTY_DATASYNC)) { 364 D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino)); 365 return; 366 } 367 368 D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino)); 369 370 iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME; 371 iattr.ia_mode = inode->i_mode; 372 iattr.ia_uid = inode->i_uid; 373 iattr.ia_gid = inode->i_gid; 374 iattr.ia_atime = inode->i_atime; 375 iattr.ia_mtime = inode->i_mtime; 376 iattr.ia_ctime = inode->i_ctime; 377 378 jffs2_do_setattr(inode, &iattr); 379 } 380 381 int jffs2_remount_fs (struct super_block *sb, int *flags, char *data) 382 { 383 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb); 384 385 if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY)) 386 return -EROFS; 387 388 /* We stop if it was running, then restart if it needs to. 389 This also catches the case where it was stopped and this 390 is just a remount to restart it. 391 Flush the writebuffer, if neccecary, else we loose it */ 392 lock_kernel(); 393 if (!(sb->s_flags & MS_RDONLY)) { 394 jffs2_stop_garbage_collect_thread(c); 395 mutex_lock(&c->alloc_sem); 396 jffs2_flush_wbuf_pad(c); 397 mutex_unlock(&c->alloc_sem); 398 } 399 400 if (!(*flags & MS_RDONLY)) 401 jffs2_start_garbage_collect_thread(c); 402 403 *flags |= MS_NOATIME; 404 405 unlock_kernel(); 406 return 0; 407 } 408 409 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash, 410 fill in the raw_inode while you're at it. */ 411 struct inode *jffs2_new_inode (struct inode *dir_i, int mode, struct jffs2_raw_inode *ri) 412 { 413 struct inode *inode; 414 struct super_block *sb = dir_i->i_sb; 415 struct jffs2_sb_info *c; 416 struct jffs2_inode_info *f; 417 int ret; 418 419 D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode)); 420 421 c = JFFS2_SB_INFO(sb); 422 423 inode = new_inode(sb); 424 425 if (!inode) 426 return ERR_PTR(-ENOMEM); 427 428 f = JFFS2_INODE_INFO(inode); 429 jffs2_init_inode_info(f); 430 mutex_lock(&f->sem); 431 432 memset(ri, 0, sizeof(*ri)); 433 /* Set OS-specific defaults for new inodes */ 434 ri->uid = cpu_to_je16(current_fsuid()); 435 436 if (dir_i->i_mode & S_ISGID) { 437 ri->gid = cpu_to_je16(dir_i->i_gid); 438 if (S_ISDIR(mode)) 439 mode |= S_ISGID; 440 } else { 441 ri->gid = cpu_to_je16(current_fsgid()); 442 } 443 444 /* POSIX ACLs have to be processed now, at least partly. 445 The umask is only applied if there's no default ACL */ 446 ret = jffs2_init_acl_pre(dir_i, inode, &mode); 447 if (ret) { 448 make_bad_inode(inode); 449 iput(inode); 450 return ERR_PTR(ret); 451 } 452 ret = jffs2_do_new_inode (c, f, mode, ri); 453 if (ret) { 454 make_bad_inode(inode); 455 iput(inode); 456 return ERR_PTR(ret); 457 } 458 inode->i_nlink = 1; 459 inode->i_ino = je32_to_cpu(ri->ino); 460 inode->i_mode = jemode_to_cpu(ri->mode); 461 inode->i_gid = je16_to_cpu(ri->gid); 462 inode->i_uid = je16_to_cpu(ri->uid); 463 inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC; 464 ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime)); 465 466 inode->i_blocks = 0; 467 inode->i_size = 0; 468 469 if (insert_inode_locked(inode) < 0) { 470 make_bad_inode(inode); 471 unlock_new_inode(inode); 472 iput(inode); 473 return ERR_PTR(-EINVAL); 474 } 475 476 return inode; 477 } 478 479 480 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent) 481 { 482 struct jffs2_sb_info *c; 483 struct inode *root_i; 484 int ret; 485 size_t blocks; 486 487 c = JFFS2_SB_INFO(sb); 488 489 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER 490 if (c->mtd->type == MTD_NANDFLASH) { 491 printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n"); 492 return -EINVAL; 493 } 494 if (c->mtd->type == MTD_DATAFLASH) { 495 printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n"); 496 return -EINVAL; 497 } 498 #endif 499 500 c->flash_size = c->mtd->size; 501 c->sector_size = c->mtd->erasesize; 502 blocks = c->flash_size / c->sector_size; 503 504 /* 505 * Size alignment check 506 */ 507 if ((c->sector_size * blocks) != c->flash_size) { 508 c->flash_size = c->sector_size * blocks; 509 printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n", 510 c->flash_size / 1024); 511 } 512 513 if (c->flash_size < 5*c->sector_size) { 514 printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size); 515 return -EINVAL; 516 } 517 518 c->cleanmarker_size = sizeof(struct jffs2_unknown_node); 519 520 /* NAND (or other bizarre) flash... do setup accordingly */ 521 ret = jffs2_flash_setup(c); 522 if (ret) 523 return ret; 524 525 c->inocache_list = kcalloc(INOCACHE_HASHSIZE, sizeof(struct jffs2_inode_cache *), GFP_KERNEL); 526 if (!c->inocache_list) { 527 ret = -ENOMEM; 528 goto out_wbuf; 529 } 530 531 jffs2_init_xattr_subsystem(c); 532 533 if ((ret = jffs2_do_mount_fs(c))) 534 goto out_inohash; 535 536 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n")); 537 root_i = jffs2_iget(sb, 1); 538 if (IS_ERR(root_i)) { 539 D1(printk(KERN_WARNING "get root inode failed\n")); 540 ret = PTR_ERR(root_i); 541 goto out_root; 542 } 543 544 ret = -ENOMEM; 545 546 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n")); 547 sb->s_root = d_alloc_root(root_i); 548 if (!sb->s_root) 549 goto out_root_i; 550 551 sb->s_maxbytes = 0xFFFFFFFF; 552 sb->s_blocksize = PAGE_CACHE_SIZE; 553 sb->s_blocksize_bits = PAGE_CACHE_SHIFT; 554 sb->s_magic = JFFS2_SUPER_MAGIC; 555 if (!(sb->s_flags & MS_RDONLY)) 556 jffs2_start_garbage_collect_thread(c); 557 return 0; 558 559 out_root_i: 560 iput(root_i); 561 out_root: 562 jffs2_free_ino_caches(c); 563 jffs2_free_raw_node_refs(c); 564 if (jffs2_blocks_use_vmalloc(c)) 565 vfree(c->blocks); 566 else 567 kfree(c->blocks); 568 out_inohash: 569 jffs2_clear_xattr_subsystem(c); 570 kfree(c->inocache_list); 571 out_wbuf: 572 jffs2_flash_cleanup(c); 573 574 return ret; 575 } 576 577 void jffs2_gc_release_inode(struct jffs2_sb_info *c, 578 struct jffs2_inode_info *f) 579 { 580 iput(OFNI_EDONI_2SFFJ(f)); 581 } 582 583 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c, 584 int inum, int unlinked) 585 { 586 struct inode *inode; 587 struct jffs2_inode_cache *ic; 588 589 if (unlinked) { 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. unlinked %d\n", 638 inum, unlinked); 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