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