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 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 480 /* NAND (or other bizarre) flash... do setup accordingly */ 481 ret = jffs2_flash_setup(c); 482 if (ret) 483 return ret; 484 485 c->inocache_list = kmalloc(INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *), GFP_KERNEL); 486 if (!c->inocache_list) { 487 ret = -ENOMEM; 488 goto out_wbuf; 489 } 490 memset(c->inocache_list, 0, INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *)); 491 492 if ((ret = jffs2_do_mount_fs(c))) 493 goto out_inohash; 494 495 ret = -EINVAL; 496 497 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n")); 498 root_i = iget(sb, 1); 499 if (is_bad_inode(root_i)) { 500 D1(printk(KERN_WARNING "get root inode failed\n")); 501 goto out_root_i; 502 } 503 504 D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n")); 505 sb->s_root = d_alloc_root(root_i); 506 if (!sb->s_root) 507 goto out_root_i; 508 509 sb->s_maxbytes = 0xFFFFFFFF; 510 sb->s_blocksize = PAGE_CACHE_SIZE; 511 sb->s_blocksize_bits = PAGE_CACHE_SHIFT; 512 sb->s_magic = JFFS2_SUPER_MAGIC; 513 if (!(sb->s_flags & MS_RDONLY)) 514 jffs2_start_garbage_collect_thread(c); 515 return 0; 516 517 out_root_i: 518 iput(root_i); 519 jffs2_free_ino_caches(c); 520 jffs2_free_raw_node_refs(c); 521 if (jffs2_blocks_use_vmalloc(c)) 522 vfree(c->blocks); 523 else 524 kfree(c->blocks); 525 out_inohash: 526 kfree(c->inocache_list); 527 out_wbuf: 528 jffs2_flash_cleanup(c); 529 530 return ret; 531 } 532 533 void jffs2_gc_release_inode(struct jffs2_sb_info *c, 534 struct jffs2_inode_info *f) 535 { 536 iput(OFNI_EDONI_2SFFJ(f)); 537 } 538 539 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c, 540 int inum, int nlink) 541 { 542 struct inode *inode; 543 struct jffs2_inode_cache *ic; 544 if (!nlink) { 545 /* The inode has zero nlink but its nodes weren't yet marked 546 obsolete. This has to be because we're still waiting for 547 the final (close() and) iput() to happen. 548 549 There's a possibility that the final iput() could have 550 happened while we were contemplating. In order to ensure 551 that we don't cause a new read_inode() (which would fail) 552 for the inode in question, we use ilookup() in this case 553 instead of iget(). 554 555 The nlink can't _become_ zero at this point because we're 556 holding the alloc_sem, and jffs2_do_unlink() would also 557 need that while decrementing nlink on any inode. 558 */ 559 inode = ilookup(OFNI_BS_2SFFJ(c), inum); 560 if (!inode) { 561 D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n", 562 inum)); 563 564 spin_lock(&c->inocache_lock); 565 ic = jffs2_get_ino_cache(c, inum); 566 if (!ic) { 567 D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum)); 568 spin_unlock(&c->inocache_lock); 569 return NULL; 570 } 571 if (ic->state != INO_STATE_CHECKEDABSENT) { 572 /* Wait for progress. Don't just loop */ 573 D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n", 574 ic->ino, ic->state)); 575 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock); 576 } else { 577 spin_unlock(&c->inocache_lock); 578 } 579 580 return NULL; 581 } 582 } else { 583 /* Inode has links to it still; they're not going away because 584 jffs2_do_unlink() would need the alloc_sem and we have it. 585 Just iget() it, and if read_inode() is necessary that's OK. 586 */ 587 inode = iget(OFNI_BS_2SFFJ(c), inum); 588 if (!inode) 589 return ERR_PTR(-ENOMEM); 590 } 591 if (is_bad_inode(inode)) { 592 printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. nlink %d\n", 593 inum, nlink); 594 /* NB. This will happen again. We need to do something appropriate here. */ 595 iput(inode); 596 return ERR_PTR(-EIO); 597 } 598 599 return JFFS2_INODE_INFO(inode); 600 } 601 602 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c, 603 struct jffs2_inode_info *f, 604 unsigned long offset, 605 unsigned long *priv) 606 { 607 struct inode *inode = OFNI_EDONI_2SFFJ(f); 608 struct page *pg; 609 610 pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT, 611 (void *)jffs2_do_readpage_unlock, inode); 612 if (IS_ERR(pg)) 613 return (void *)pg; 614 615 *priv = (unsigned long)pg; 616 return kmap(pg); 617 } 618 619 void jffs2_gc_release_page(struct jffs2_sb_info *c, 620 unsigned char *ptr, 621 unsigned long *priv) 622 { 623 struct page *pg = (void *)*priv; 624 625 kunmap(pg); 626 page_cache_release(pg); 627 } 628 629 static int jffs2_flash_setup(struct jffs2_sb_info *c) { 630 int ret = 0; 631 632 if (jffs2_cleanmarker_oob(c)) { 633 /* NAND flash... do setup accordingly */ 634 ret = jffs2_nand_flash_setup(c); 635 if (ret) 636 return ret; 637 } 638 639 /* add setups for other bizarre flashes here... */ 640 if (jffs2_nor_ecc(c)) { 641 ret = jffs2_nor_ecc_flash_setup(c); 642 if (ret) 643 return ret; 644 } 645 646 /* and Dataflash */ 647 if (jffs2_dataflash(c)) { 648 ret = jffs2_dataflash_setup(c); 649 if (ret) 650 return ret; 651 } 652 653 /* and Intel "Sibley" flash */ 654 if (jffs2_nor_wbuf_flash(c)) { 655 ret = jffs2_nor_wbuf_flash_setup(c); 656 if (ret) 657 return ret; 658 } 659 660 return ret; 661 } 662 663 void jffs2_flash_cleanup(struct jffs2_sb_info *c) { 664 665 if (jffs2_cleanmarker_oob(c)) { 666 jffs2_nand_flash_cleanup(c); 667 } 668 669 /* add cleanups for other bizarre flashes here... */ 670 if (jffs2_nor_ecc(c)) { 671 jffs2_nor_ecc_flash_cleanup(c); 672 } 673 674 /* and DataFlash */ 675 if (jffs2_dataflash(c)) { 676 jffs2_dataflash_cleanup(c); 677 } 678 679 /* and Intel "Sibley" flash */ 680 if (jffs2_nor_wbuf_flash(c)) { 681 jffs2_nor_wbuf_flash_cleanup(c); 682 } 683 } 684