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