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