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