1 /* 2 * JFFS2 -- Journalling Flash File System, Version 2. 3 * 4 * Copyright © 2001-2007 Red Hat, Inc. 5 * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org> 6 * 7 * Created by David Woodhouse <dwmw2@infradead.org> 8 * 9 * For licensing information, see the file 'LICENCE' in this directory. 10 * 11 */ 12 13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 14 15 #include <linux/capability.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 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 union jffs2_device_node dev; 37 unsigned char *mdata = NULL; 38 int mdatalen = 0; 39 unsigned int ivalid; 40 uint32_t alloclen; 41 int ret; 42 int alloc_type = ALLOC_NORMAL; 43 44 jffs2_dbg(1, "%s(): ino #%lu\n", __func__, inode->i_ino); 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 mdatalen = jffs2_encode_dev(&dev, inode->i_rdev); 54 mdata = (char *)&dev; 55 jffs2_dbg(1, "%s(): Writing %d bytes of kdev_t\n", 56 __func__, mdatalen); 57 } else if (S_ISLNK(inode->i_mode)) { 58 mutex_lock(&f->sem); 59 mdatalen = f->metadata->size; 60 mdata = kmalloc(f->metadata->size, GFP_USER); 61 if (!mdata) { 62 mutex_unlock(&f->sem); 63 return -ENOMEM; 64 } 65 ret = jffs2_read_dnode(c, f, f->metadata, mdata, 0, mdatalen); 66 if (ret) { 67 mutex_unlock(&f->sem); 68 kfree(mdata); 69 return ret; 70 } 71 mutex_unlock(&f->sem); 72 jffs2_dbg(1, "%s(): Writing %d bytes of symlink target\n", 73 __func__, 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, &alloclen, 84 ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE); 85 if (ret) { 86 jffs2_free_raw_inode(ri); 87 if (S_ISLNK(inode->i_mode)) 88 kfree(mdata); 89 return ret; 90 } 91 mutex_lock(&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)? 103 from_kuid(&init_user_ns, iattr->ia_uid):i_uid_read(inode)); 104 ri->gid = cpu_to_je16((ivalid & ATTR_GID)? 105 from_kgid(&init_user_ns, iattr->ia_gid):i_gid_read(inode)); 106 107 if (ivalid & ATTR_MODE) 108 ri->mode = cpu_to_jemode(iattr->ia_mode); 109 else 110 ri->mode = cpu_to_jemode(inode->i_mode); 111 112 113 ri->isize = cpu_to_je32((ivalid & ATTR_SIZE)?iattr->ia_size:inode->i_size); 114 ri->atime = cpu_to_je32(I_SEC((ivalid & ATTR_ATIME)?iattr->ia_atime:inode->i_atime)); 115 ri->mtime = cpu_to_je32(I_SEC((ivalid & ATTR_MTIME)?iattr->ia_mtime:inode->i_mtime)); 116 ri->ctime = cpu_to_je32(I_SEC((ivalid & ATTR_CTIME)?iattr->ia_ctime:inode->i_ctime)); 117 118 ri->offset = cpu_to_je32(0); 119 ri->csize = ri->dsize = cpu_to_je32(mdatalen); 120 ri->compr = JFFS2_COMPR_NONE; 121 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) { 122 /* It's an extension. Make it a hole node */ 123 ri->compr = JFFS2_COMPR_ZERO; 124 ri->dsize = cpu_to_je32(iattr->ia_size - inode->i_size); 125 ri->offset = cpu_to_je32(inode->i_size); 126 } else if (ivalid & ATTR_SIZE && !iattr->ia_size) { 127 /* For truncate-to-zero, treat it as deletion because 128 it'll always be obsoleting all previous nodes */ 129 alloc_type = ALLOC_DELETION; 130 } 131 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 132 if (mdatalen) 133 ri->data_crc = cpu_to_je32(crc32(0, mdata, mdatalen)); 134 else 135 ri->data_crc = cpu_to_je32(0); 136 137 new_metadata = jffs2_write_dnode(c, f, ri, mdata, mdatalen, alloc_type); 138 if (S_ISLNK(inode->i_mode)) 139 kfree(mdata); 140 141 if (IS_ERR(new_metadata)) { 142 jffs2_complete_reservation(c); 143 jffs2_free_raw_inode(ri); 144 mutex_unlock(&f->sem); 145 return PTR_ERR(new_metadata); 146 } 147 /* It worked. Update the inode */ 148 inode->i_atime = ITIME(je32_to_cpu(ri->atime)); 149 inode->i_ctime = ITIME(je32_to_cpu(ri->ctime)); 150 inode->i_mtime = ITIME(je32_to_cpu(ri->mtime)); 151 inode->i_mode = jemode_to_cpu(ri->mode); 152 i_uid_write(inode, je16_to_cpu(ri->uid)); 153 i_gid_write(inode, je16_to_cpu(ri->gid)); 154 155 156 old_metadata = f->metadata; 157 158 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size) 159 jffs2_truncate_fragtree (c, &f->fragtree, iattr->ia_size); 160 161 if (ivalid & ATTR_SIZE && inode->i_size < iattr->ia_size) { 162 jffs2_add_full_dnode_to_inode(c, f, new_metadata); 163 inode->i_size = iattr->ia_size; 164 inode->i_blocks = (inode->i_size + 511) >> 9; 165 f->metadata = NULL; 166 } else { 167 f->metadata = new_metadata; 168 } 169 if (old_metadata) { 170 jffs2_mark_node_obsolete(c, old_metadata->raw); 171 jffs2_free_full_dnode(old_metadata); 172 } 173 jffs2_free_raw_inode(ri); 174 175 mutex_unlock(&f->sem); 176 jffs2_complete_reservation(c); 177 178 /* We have to do the truncate_setsize() without f->sem held, since 179 some pages may be locked and waiting for it in readpage(). 180 We are protected from a simultaneous write() extending i_size 181 back past iattr->ia_size, because do_truncate() holds the 182 generic inode semaphore. */ 183 if (ivalid & ATTR_SIZE && inode->i_size > iattr->ia_size) { 184 truncate_setsize(inode, iattr->ia_size); 185 inode->i_blocks = (inode->i_size + 511) >> 9; 186 } 187 188 return 0; 189 } 190 191 int jffs2_setattr(struct dentry *dentry, struct iattr *iattr) 192 { 193 struct inode *inode = dentry->d_inode; 194 int rc; 195 196 rc = inode_change_ok(inode, iattr); 197 if (rc) 198 return rc; 199 200 rc = jffs2_do_setattr(inode, iattr); 201 if (!rc && (iattr->ia_valid & ATTR_MODE)) 202 rc = posix_acl_chmod(inode, inode->i_mode); 203 204 return rc; 205 } 206 207 int jffs2_statfs(struct dentry *dentry, struct kstatfs *buf) 208 { 209 struct jffs2_sb_info *c = JFFS2_SB_INFO(dentry->d_sb); 210 unsigned long avail; 211 212 buf->f_type = JFFS2_SUPER_MAGIC; 213 buf->f_bsize = 1 << PAGE_SHIFT; 214 buf->f_blocks = c->flash_size >> PAGE_SHIFT; 215 buf->f_files = 0; 216 buf->f_ffree = 0; 217 buf->f_namelen = JFFS2_MAX_NAME_LEN; 218 buf->f_fsid.val[0] = JFFS2_SUPER_MAGIC; 219 buf->f_fsid.val[1] = c->mtd->index; 220 221 spin_lock(&c->erase_completion_lock); 222 avail = c->dirty_size + c->free_size; 223 if (avail > c->sector_size * c->resv_blocks_write) 224 avail -= c->sector_size * c->resv_blocks_write; 225 else 226 avail = 0; 227 spin_unlock(&c->erase_completion_lock); 228 229 buf->f_bavail = buf->f_bfree = avail >> PAGE_SHIFT; 230 231 return 0; 232 } 233 234 235 void jffs2_evict_inode (struct inode *inode) 236 { 237 /* We can forget about this inode for now - drop all 238 * the nodelists associated with it, etc. 239 */ 240 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb); 241 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode); 242 243 jffs2_dbg(1, "%s(): ino #%lu mode %o\n", 244 __func__, inode->i_ino, inode->i_mode); 245 truncate_inode_pages_final(&inode->i_data); 246 clear_inode(inode); 247 jffs2_do_clear_inode(c, f); 248 } 249 250 struct inode *jffs2_iget(struct super_block *sb, unsigned long ino) 251 { 252 struct jffs2_inode_info *f; 253 struct jffs2_sb_info *c; 254 struct jffs2_raw_inode latest_node; 255 union jffs2_device_node jdev; 256 struct inode *inode; 257 dev_t rdev = 0; 258 int ret; 259 260 jffs2_dbg(1, "%s(): ino == %lu\n", __func__, ino); 261 262 inode = iget_locked(sb, ino); 263 if (!inode) 264 return ERR_PTR(-ENOMEM); 265 if (!(inode->i_state & I_NEW)) 266 return inode; 267 268 f = JFFS2_INODE_INFO(inode); 269 c = JFFS2_SB_INFO(inode->i_sb); 270 271 jffs2_init_inode_info(f); 272 mutex_lock(&f->sem); 273 274 ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node); 275 276 if (ret) { 277 mutex_unlock(&f->sem); 278 iget_failed(inode); 279 return ERR_PTR(ret); 280 } 281 inode->i_mode = jemode_to_cpu(latest_node.mode); 282 i_uid_write(inode, je16_to_cpu(latest_node.uid)); 283 i_gid_write(inode, je16_to_cpu(latest_node.gid)); 284 inode->i_size = je32_to_cpu(latest_node.isize); 285 inode->i_atime = ITIME(je32_to_cpu(latest_node.atime)); 286 inode->i_mtime = ITIME(je32_to_cpu(latest_node.mtime)); 287 inode->i_ctime = ITIME(je32_to_cpu(latest_node.ctime)); 288 289 set_nlink(inode, f->inocache->pino_nlink); 290 291 inode->i_blocks = (inode->i_size + 511) >> 9; 292 293 switch (inode->i_mode & S_IFMT) { 294 295 case S_IFLNK: 296 inode->i_op = &jffs2_symlink_inode_operations; 297 break; 298 299 case S_IFDIR: 300 { 301 struct jffs2_full_dirent *fd; 302 set_nlink(inode, 2); /* parent and '.' */ 303 304 for (fd=f->dents; fd; fd = fd->next) { 305 if (fd->type == DT_DIR && fd->ino) 306 inc_nlink(inode); 307 } 308 /* Root dir gets i_nlink 3 for some reason */ 309 if (inode->i_ino == 1) 310 inc_nlink(inode); 311 312 inode->i_op = &jffs2_dir_inode_operations; 313 inode->i_fop = &jffs2_dir_operations; 314 break; 315 } 316 case S_IFREG: 317 inode->i_op = &jffs2_file_inode_operations; 318 inode->i_fop = &jffs2_file_operations; 319 inode->i_mapping->a_ops = &jffs2_file_address_operations; 320 inode->i_mapping->nrpages = 0; 321 break; 322 323 case S_IFBLK: 324 case S_IFCHR: 325 /* Read the device numbers from the media */ 326 if (f->metadata->size != sizeof(jdev.old_id) && 327 f->metadata->size != sizeof(jdev.new_id)) { 328 pr_notice("Device node has strange size %d\n", 329 f->metadata->size); 330 goto error_io; 331 } 332 jffs2_dbg(1, "Reading device numbers from flash\n"); 333 ret = jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size); 334 if (ret < 0) { 335 /* Eep */ 336 pr_notice("Read device numbers for inode %lu failed\n", 337 (unsigned long)inode->i_ino); 338 goto error; 339 } 340 if (f->metadata->size == sizeof(jdev.old_id)) 341 rdev = old_decode_dev(je16_to_cpu(jdev.old_id)); 342 else 343 rdev = new_decode_dev(je32_to_cpu(jdev.new_id)); 344 345 case S_IFSOCK: 346 case S_IFIFO: 347 inode->i_op = &jffs2_file_inode_operations; 348 init_special_inode(inode, inode->i_mode, rdev); 349 break; 350 351 default: 352 pr_warn("%s(): Bogus i_mode %o for ino %lu\n", 353 __func__, inode->i_mode, (unsigned long)inode->i_ino); 354 } 355 356 mutex_unlock(&f->sem); 357 358 jffs2_dbg(1, "jffs2_read_inode() returning\n"); 359 unlock_new_inode(inode); 360 return inode; 361 362 error_io: 363 ret = -EIO; 364 error: 365 mutex_unlock(&f->sem); 366 jffs2_do_clear_inode(c, f); 367 iget_failed(inode); 368 return ERR_PTR(ret); 369 } 370 371 void jffs2_dirty_inode(struct inode *inode, int flags) 372 { 373 struct iattr iattr; 374 375 if (!(inode->i_state & I_DIRTY_DATASYNC)) { 376 jffs2_dbg(2, "%s(): not calling setattr() for ino #%lu\n", 377 __func__, inode->i_ino); 378 return; 379 } 380 381 jffs2_dbg(1, "%s(): calling setattr() for ino #%lu\n", 382 __func__, inode->i_ino); 383 384 iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME; 385 iattr.ia_mode = inode->i_mode; 386 iattr.ia_uid = inode->i_uid; 387 iattr.ia_gid = inode->i_gid; 388 iattr.ia_atime = inode->i_atime; 389 iattr.ia_mtime = inode->i_mtime; 390 iattr.ia_ctime = inode->i_ctime; 391 392 jffs2_do_setattr(inode, &iattr); 393 } 394 395 int jffs2_do_remount_fs(struct super_block *sb, int *flags, char *data) 396 { 397 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb); 398 399 if (c->flags & JFFS2_SB_FLAG_RO && !(sb->s_flags & MS_RDONLY)) 400 return -EROFS; 401 402 /* We stop if it was running, then restart if it needs to. 403 This also catches the case where it was stopped and this 404 is just a remount to restart it. 405 Flush the writebuffer, if neccecary, else we loose it */ 406 if (!(sb->s_flags & MS_RDONLY)) { 407 jffs2_stop_garbage_collect_thread(c); 408 mutex_lock(&c->alloc_sem); 409 jffs2_flush_wbuf_pad(c); 410 mutex_unlock(&c->alloc_sem); 411 } 412 413 if (!(*flags & MS_RDONLY)) 414 jffs2_start_garbage_collect_thread(c); 415 416 *flags |= MS_NOATIME; 417 return 0; 418 } 419 420 /* jffs2_new_inode: allocate a new inode and inocache, add it to the hash, 421 fill in the raw_inode while you're at it. */ 422 struct inode *jffs2_new_inode (struct inode *dir_i, umode_t mode, struct jffs2_raw_inode *ri) 423 { 424 struct inode *inode; 425 struct super_block *sb = dir_i->i_sb; 426 struct jffs2_sb_info *c; 427 struct jffs2_inode_info *f; 428 int ret; 429 430 jffs2_dbg(1, "%s(): dir_i %ld, mode 0x%x\n", 431 __func__, dir_i->i_ino, mode); 432 433 c = JFFS2_SB_INFO(sb); 434 435 inode = new_inode(sb); 436 437 if (!inode) 438 return ERR_PTR(-ENOMEM); 439 440 f = JFFS2_INODE_INFO(inode); 441 jffs2_init_inode_info(f); 442 mutex_lock(&f->sem); 443 444 memset(ri, 0, sizeof(*ri)); 445 /* Set OS-specific defaults for new inodes */ 446 ri->uid = cpu_to_je16(from_kuid(&init_user_ns, current_fsuid())); 447 448 if (dir_i->i_mode & S_ISGID) { 449 ri->gid = cpu_to_je16(i_gid_read(dir_i)); 450 if (S_ISDIR(mode)) 451 mode |= S_ISGID; 452 } else { 453 ri->gid = cpu_to_je16(from_kgid(&init_user_ns, current_fsgid())); 454 } 455 456 /* POSIX ACLs have to be processed now, at least partly. 457 The umask is only applied if there's no default ACL */ 458 ret = jffs2_init_acl_pre(dir_i, inode, &mode); 459 if (ret) { 460 mutex_unlock(&f->sem); 461 make_bad_inode(inode); 462 iput(inode); 463 return ERR_PTR(ret); 464 } 465 ret = jffs2_do_new_inode (c, f, mode, ri); 466 if (ret) { 467 mutex_unlock(&f->sem); 468 make_bad_inode(inode); 469 iput(inode); 470 return ERR_PTR(ret); 471 } 472 set_nlink(inode, 1); 473 inode->i_ino = je32_to_cpu(ri->ino); 474 inode->i_mode = jemode_to_cpu(ri->mode); 475 i_gid_write(inode, je16_to_cpu(ri->gid)); 476 i_uid_write(inode, je16_to_cpu(ri->uid)); 477 inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC; 478 ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime)); 479 480 inode->i_blocks = 0; 481 inode->i_size = 0; 482 483 if (insert_inode_locked(inode) < 0) { 484 mutex_unlock(&f->sem); 485 make_bad_inode(inode); 486 iput(inode); 487 return ERR_PTR(-EINVAL); 488 } 489 490 return inode; 491 } 492 493 static int calculate_inocache_hashsize(uint32_t flash_size) 494 { 495 /* 496 * Pick a inocache hash size based on the size of the medium. 497 * Count how many megabytes we're dealing with, apply a hashsize twice 498 * that size, but rounding down to the usual big powers of 2. And keep 499 * to sensible bounds. 500 */ 501 502 int size_mb = flash_size / 1024 / 1024; 503 int hashsize = (size_mb * 2) & ~0x3f; 504 505 if (hashsize < INOCACHE_HASHSIZE_MIN) 506 return INOCACHE_HASHSIZE_MIN; 507 if (hashsize > INOCACHE_HASHSIZE_MAX) 508 return INOCACHE_HASHSIZE_MAX; 509 510 return hashsize; 511 } 512 513 int jffs2_do_fill_super(struct super_block *sb, void *data, int silent) 514 { 515 struct jffs2_sb_info *c; 516 struct inode *root_i; 517 int ret; 518 size_t blocks; 519 520 c = JFFS2_SB_INFO(sb); 521 522 /* Do not support the MLC nand */ 523 if (c->mtd->type == MTD_MLCNANDFLASH) 524 return -EINVAL; 525 526 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER 527 if (c->mtd->type == MTD_NANDFLASH) { 528 pr_err("Cannot operate on NAND flash unless jffs2 NAND support is compiled in\n"); 529 return -EINVAL; 530 } 531 if (c->mtd->type == MTD_DATAFLASH) { 532 pr_err("Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in\n"); 533 return -EINVAL; 534 } 535 #endif 536 537 c->flash_size = c->mtd->size; 538 c->sector_size = c->mtd->erasesize; 539 blocks = c->flash_size / c->sector_size; 540 541 /* 542 * Size alignment check 543 */ 544 if ((c->sector_size * blocks) != c->flash_size) { 545 c->flash_size = c->sector_size * blocks; 546 pr_info("Flash size not aligned to erasesize, reducing to %dKiB\n", 547 c->flash_size / 1024); 548 } 549 550 if (c->flash_size < 5*c->sector_size) { 551 pr_err("Too few erase blocks (%d)\n", 552 c->flash_size / c->sector_size); 553 return -EINVAL; 554 } 555 556 c->cleanmarker_size = sizeof(struct jffs2_unknown_node); 557 558 /* NAND (or other bizarre) flash... do setup accordingly */ 559 ret = jffs2_flash_setup(c); 560 if (ret) 561 return ret; 562 563 c->inocache_hashsize = calculate_inocache_hashsize(c->flash_size); 564 c->inocache_list = kcalloc(c->inocache_hashsize, sizeof(struct jffs2_inode_cache *), GFP_KERNEL); 565 if (!c->inocache_list) { 566 ret = -ENOMEM; 567 goto out_wbuf; 568 } 569 570 jffs2_init_xattr_subsystem(c); 571 572 if ((ret = jffs2_do_mount_fs(c))) 573 goto out_inohash; 574 575 jffs2_dbg(1, "%s(): Getting root inode\n", __func__); 576 root_i = jffs2_iget(sb, 1); 577 if (IS_ERR(root_i)) { 578 jffs2_dbg(1, "get root inode failed\n"); 579 ret = PTR_ERR(root_i); 580 goto out_root; 581 } 582 583 ret = -ENOMEM; 584 585 jffs2_dbg(1, "%s(): d_make_root()\n", __func__); 586 sb->s_root = d_make_root(root_i); 587 if (!sb->s_root) 588 goto out_root; 589 590 sb->s_maxbytes = 0xFFFFFFFF; 591 sb->s_blocksize = PAGE_CACHE_SIZE; 592 sb->s_blocksize_bits = PAGE_CACHE_SHIFT; 593 sb->s_magic = JFFS2_SUPER_MAGIC; 594 if (!(sb->s_flags & MS_RDONLY)) 595 jffs2_start_garbage_collect_thread(c); 596 return 0; 597 598 out_root: 599 jffs2_free_ino_caches(c); 600 jffs2_free_raw_node_refs(c); 601 if (jffs2_blocks_use_vmalloc(c)) 602 vfree(c->blocks); 603 else 604 kfree(c->blocks); 605 out_inohash: 606 jffs2_clear_xattr_subsystem(c); 607 kfree(c->inocache_list); 608 out_wbuf: 609 jffs2_flash_cleanup(c); 610 611 return ret; 612 } 613 614 void jffs2_gc_release_inode(struct jffs2_sb_info *c, 615 struct jffs2_inode_info *f) 616 { 617 iput(OFNI_EDONI_2SFFJ(f)); 618 } 619 620 struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c, 621 int inum, int unlinked) 622 { 623 struct inode *inode; 624 struct jffs2_inode_cache *ic; 625 626 if (unlinked) { 627 /* The inode has zero nlink but its nodes weren't yet marked 628 obsolete. This has to be because we're still waiting for 629 the final (close() and) iput() to happen. 630 631 There's a possibility that the final iput() could have 632 happened while we were contemplating. In order to ensure 633 that we don't cause a new read_inode() (which would fail) 634 for the inode in question, we use ilookup() in this case 635 instead of iget(). 636 637 The nlink can't _become_ zero at this point because we're 638 holding the alloc_sem, and jffs2_do_unlink() would also 639 need that while decrementing nlink on any inode. 640 */ 641 inode = ilookup(OFNI_BS_2SFFJ(c), inum); 642 if (!inode) { 643 jffs2_dbg(1, "ilookup() failed for ino #%u; inode is probably deleted.\n", 644 inum); 645 646 spin_lock(&c->inocache_lock); 647 ic = jffs2_get_ino_cache(c, inum); 648 if (!ic) { 649 jffs2_dbg(1, "Inode cache for ino #%u is gone\n", 650 inum); 651 spin_unlock(&c->inocache_lock); 652 return NULL; 653 } 654 if (ic->state != INO_STATE_CHECKEDABSENT) { 655 /* Wait for progress. Don't just loop */ 656 jffs2_dbg(1, "Waiting for ino #%u in state %d\n", 657 ic->ino, ic->state); 658 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock); 659 } else { 660 spin_unlock(&c->inocache_lock); 661 } 662 663 return NULL; 664 } 665 } else { 666 /* Inode has links to it still; they're not going away because 667 jffs2_do_unlink() would need the alloc_sem and we have it. 668 Just iget() it, and if read_inode() is necessary that's OK. 669 */ 670 inode = jffs2_iget(OFNI_BS_2SFFJ(c), inum); 671 if (IS_ERR(inode)) 672 return ERR_CAST(inode); 673 } 674 if (is_bad_inode(inode)) { 675 pr_notice("Eep. read_inode() failed for ino #%u. unlinked %d\n", 676 inum, unlinked); 677 /* NB. This will happen again. We need to do something appropriate here. */ 678 iput(inode); 679 return ERR_PTR(-EIO); 680 } 681 682 return JFFS2_INODE_INFO(inode); 683 } 684 685 unsigned char *jffs2_gc_fetch_page(struct jffs2_sb_info *c, 686 struct jffs2_inode_info *f, 687 unsigned long offset, 688 unsigned long *priv) 689 { 690 struct inode *inode = OFNI_EDONI_2SFFJ(f); 691 struct page *pg; 692 693 pg = read_cache_page(inode->i_mapping, offset >> PAGE_CACHE_SHIFT, 694 (void *)jffs2_do_readpage_unlock, inode); 695 if (IS_ERR(pg)) 696 return (void *)pg; 697 698 *priv = (unsigned long)pg; 699 return kmap(pg); 700 } 701 702 void jffs2_gc_release_page(struct jffs2_sb_info *c, 703 unsigned char *ptr, 704 unsigned long *priv) 705 { 706 struct page *pg = (void *)*priv; 707 708 kunmap(pg); 709 page_cache_release(pg); 710 } 711 712 static int jffs2_flash_setup(struct jffs2_sb_info *c) { 713 int ret = 0; 714 715 if (jffs2_cleanmarker_oob(c)) { 716 /* NAND flash... do setup accordingly */ 717 ret = jffs2_nand_flash_setup(c); 718 if (ret) 719 return ret; 720 } 721 722 /* and Dataflash */ 723 if (jffs2_dataflash(c)) { 724 ret = jffs2_dataflash_setup(c); 725 if (ret) 726 return ret; 727 } 728 729 /* and Intel "Sibley" flash */ 730 if (jffs2_nor_wbuf_flash(c)) { 731 ret = jffs2_nor_wbuf_flash_setup(c); 732 if (ret) 733 return ret; 734 } 735 736 /* and an UBI volume */ 737 if (jffs2_ubivol(c)) { 738 ret = jffs2_ubivol_setup(c); 739 if (ret) 740 return ret; 741 } 742 743 return ret; 744 } 745 746 void jffs2_flash_cleanup(struct jffs2_sb_info *c) { 747 748 if (jffs2_cleanmarker_oob(c)) { 749 jffs2_nand_flash_cleanup(c); 750 } 751 752 /* and DataFlash */ 753 if (jffs2_dataflash(c)) { 754 jffs2_dataflash_cleanup(c); 755 } 756 757 /* and Intel "Sibley" flash */ 758 if (jffs2_nor_wbuf_flash(c)) { 759 jffs2_nor_wbuf_flash_cleanup(c); 760 } 761 762 /* and an UBI volume */ 763 if (jffs2_ubivol(c)) { 764 jffs2_ubivol_cleanup(c); 765 } 766 } 767