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