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