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/kernel.h> 16#include <linux/slab.h> 17#include <linux/fs.h> 18#include <linux/crc32.h> 19#include <linux/jffs2.h> 20#include "jffs2_fs_i.h" 21#include "jffs2_fs_sb.h" 22#include <linux/time.h> 23#include "nodelist.h" 24 25static int jffs2_readdir (struct file *, struct dir_context *); 26 27static int jffs2_create (struct mnt_idmap *, struct inode *, 28 struct dentry *, umode_t, bool); 29static struct dentry *jffs2_lookup (struct inode *,struct dentry *, 30 unsigned int); 31static int jffs2_link (struct dentry *,struct inode *,struct dentry *); 32static int jffs2_unlink (struct inode *,struct dentry *); 33static int jffs2_symlink (struct mnt_idmap *, struct inode *, 34 struct dentry *, const char *); 35static int jffs2_mkdir (struct mnt_idmap *, struct inode *,struct dentry *, 36 umode_t); 37static int jffs2_rmdir (struct inode *,struct dentry *); 38static int jffs2_mknod (struct mnt_idmap *, struct inode *,struct dentry *, 39 umode_t,dev_t); 40static int jffs2_rename (struct mnt_idmap *, struct inode *, 41 struct dentry *, struct inode *, struct dentry *, 42 unsigned int); 43 44const struct file_operations jffs2_dir_operations = 45{ 46 .read = generic_read_dir, 47 .iterate_shared=jffs2_readdir, 48 .unlocked_ioctl=jffs2_ioctl, 49 .fsync = jffs2_fsync, 50 .llseek = generic_file_llseek, 51}; 52 53 54const struct inode_operations jffs2_dir_inode_operations = 55{ 56 .create = jffs2_create, 57 .lookup = jffs2_lookup, 58 .link = jffs2_link, 59 .unlink = jffs2_unlink, 60 .symlink = jffs2_symlink, 61 .mkdir = jffs2_mkdir, 62 .rmdir = jffs2_rmdir, 63 .mknod = jffs2_mknod, 64 .rename = jffs2_rename, 65 .get_inode_acl = jffs2_get_acl, 66 .set_acl = jffs2_set_acl, 67 .setattr = jffs2_setattr, 68 .listxattr = jffs2_listxattr, 69}; 70 71/***********************************************************************/ 72 73 74/* We keep the dirent list sorted in increasing order of name hash, 75 and we use the same hash function as the dentries. Makes this 76 nice and simple 77*/ 78static struct dentry *jffs2_lookup(struct inode *dir_i, struct dentry *target, 79 unsigned int flags) 80{ 81 struct jffs2_inode_info *dir_f; 82 struct jffs2_full_dirent *fd = NULL, *fd_list; 83 uint32_t ino = 0; 84 struct inode *inode = NULL; 85 unsigned int nhash; 86 87 jffs2_dbg(1, "jffs2_lookup()\n"); 88 89 if (target->d_name.len > JFFS2_MAX_NAME_LEN) 90 return ERR_PTR(-ENAMETOOLONG); 91 92 dir_f = JFFS2_INODE_INFO(dir_i); 93 94 /* The 'nhash' on the fd_list is not the same as the dentry hash */ 95 nhash = full_name_hash(NULL, target->d_name.name, target->d_name.len); 96 97 mutex_lock(&dir_f->sem); 98 99 /* NB: The 2.2 backport will need to explicitly check for '.' and '..' here */ 100 for (fd_list = dir_f->dents; fd_list && fd_list->nhash <= nhash; fd_list = fd_list->next) { 101 if (fd_list->nhash == nhash && 102 (!fd || fd_list->version > fd->version) && 103 strlen(fd_list->name) == target->d_name.len && 104 !strncmp(fd_list->name, target->d_name.name, target->d_name.len)) { 105 fd = fd_list; 106 } 107 } 108 if (fd) 109 ino = fd->ino; 110 mutex_unlock(&dir_f->sem); 111 if (ino) { 112 inode = jffs2_iget(dir_i->i_sb, ino); 113 if (IS_ERR(inode)) 114 pr_warn("iget() failed for ino #%u\n", ino); 115 } 116 117 return d_splice_alias(inode, target); 118} 119 120/***********************************************************************/ 121 122 123static int jffs2_readdir(struct file *file, struct dir_context *ctx) 124{ 125 struct inode *inode = file_inode(file); 126 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode); 127 struct jffs2_full_dirent *fd; 128 unsigned long curofs = 1; 129 130 jffs2_dbg(1, "jffs2_readdir() for dir_i #%lu\n", inode->i_ino); 131 132 if (!dir_emit_dots(file, ctx)) 133 return 0; 134 135 mutex_lock(&f->sem); 136 for (fd = f->dents; fd; fd = fd->next) { 137 curofs++; 138 /* First loop: curofs = 2; pos = 2 */ 139 if (curofs < ctx->pos) { 140 jffs2_dbg(2, "Skipping dirent: \"%s\", ino #%u, type %d, because curofs %ld < offset %ld\n", 141 fd->name, fd->ino, fd->type, curofs, (unsigned long)ctx->pos); 142 continue; 143 } 144 if (!fd->ino) { 145 jffs2_dbg(2, "Skipping deletion dirent \"%s\"\n", 146 fd->name); 147 ctx->pos++; 148 continue; 149 } 150 jffs2_dbg(2, "Dirent %ld: \"%s\", ino #%u, type %d\n", 151 (unsigned long)ctx->pos, fd->name, fd->ino, fd->type); 152 if (!dir_emit(ctx, fd->name, strlen(fd->name), fd->ino, fd->type)) 153 break; 154 ctx->pos++; 155 } 156 mutex_unlock(&f->sem); 157 return 0; 158} 159 160/***********************************************************************/ 161 162 163static int jffs2_create(struct mnt_idmap *idmap, struct inode *dir_i, 164 struct dentry *dentry, umode_t mode, bool excl) 165{ 166 struct jffs2_raw_inode *ri; 167 struct jffs2_inode_info *f, *dir_f; 168 struct jffs2_sb_info *c; 169 struct inode *inode; 170 int ret; 171 172 ri = jffs2_alloc_raw_inode(); 173 if (!ri) 174 return -ENOMEM; 175 176 c = JFFS2_SB_INFO(dir_i->i_sb); 177 178 jffs2_dbg(1, "%s()\n", __func__); 179 180 inode = jffs2_new_inode(dir_i, mode, ri); 181 182 if (IS_ERR(inode)) { 183 jffs2_dbg(1, "jffs2_new_inode() failed\n"); 184 jffs2_free_raw_inode(ri); 185 return PTR_ERR(inode); 186 } 187 188 inode->i_op = &jffs2_file_inode_operations; 189 inode->i_fop = &jffs2_file_operations; 190 inode->i_mapping->a_ops = &jffs2_file_address_operations; 191 inode->i_mapping->nrpages = 0; 192 193 f = JFFS2_INODE_INFO(inode); 194 dir_f = JFFS2_INODE_INFO(dir_i); 195 196 /* jffs2_do_create() will want to lock it, _after_ reserving 197 space and taking c-alloc_sem. If we keep it locked here, 198 lockdep gets unhappy (although it's a false positive; 199 nothing else will be looking at this inode yet so there's 200 no chance of AB-BA deadlock involving its f->sem). */ 201 mutex_unlock(&f->sem); 202 203 ret = jffs2_do_create(c, dir_f, f, ri, &dentry->d_name); 204 if (ret) 205 goto fail; 206 207 dir_i->i_mtime = inode_set_ctime_to_ts(dir_i, 208 ITIME(je32_to_cpu(ri->ctime))); 209 210 jffs2_free_raw_inode(ri); 211 212 jffs2_dbg(1, "%s(): Created ino #%lu with mode %o, nlink %d(%d). nrpages %ld\n", 213 __func__, inode->i_ino, inode->i_mode, inode->i_nlink, 214 f->inocache->pino_nlink, inode->i_mapping->nrpages); 215 216 d_instantiate_new(dentry, inode); 217 return 0; 218 219 fail: 220 iget_failed(inode); 221 jffs2_free_raw_inode(ri); 222 return ret; 223} 224 225/***********************************************************************/ 226 227 228static int jffs2_unlink(struct inode *dir_i, struct dentry *dentry) 229{ 230 struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb); 231 struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); 232 struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(d_inode(dentry)); 233 int ret; 234 uint32_t now = JFFS2_NOW(); 235 236 ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name, 237 dentry->d_name.len, dead_f, now); 238 if (dead_f->inocache) 239 set_nlink(d_inode(dentry), dead_f->inocache->pino_nlink); 240 if (!ret) 241 dir_i->i_mtime = inode_set_ctime_to_ts(dir_i, ITIME(now)); 242 return ret; 243} 244/***********************************************************************/ 245 246 247static int jffs2_link (struct dentry *old_dentry, struct inode *dir_i, struct dentry *dentry) 248{ 249 struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dentry->d_sb); 250 struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry)); 251 struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); 252 int ret; 253 uint8_t type; 254 uint32_t now; 255 256 /* Don't let people make hard links to bad inodes. */ 257 if (!f->inocache) 258 return -EIO; 259 260 if (d_is_dir(old_dentry)) 261 return -EPERM; 262 263 /* XXX: This is ugly */ 264 type = (d_inode(old_dentry)->i_mode & S_IFMT) >> 12; 265 if (!type) type = DT_REG; 266 267 now = JFFS2_NOW(); 268 ret = jffs2_do_link(c, dir_f, f->inocache->ino, type, dentry->d_name.name, dentry->d_name.len, now); 269 270 if (!ret) { 271 mutex_lock(&f->sem); 272 set_nlink(d_inode(old_dentry), ++f->inocache->pino_nlink); 273 mutex_unlock(&f->sem); 274 d_instantiate(dentry, d_inode(old_dentry)); 275 dir_i->i_mtime = inode_set_ctime_to_ts(dir_i, ITIME(now)); 276 ihold(d_inode(old_dentry)); 277 } 278 return ret; 279} 280 281/***********************************************************************/ 282 283static int jffs2_symlink (struct mnt_idmap *idmap, struct inode *dir_i, 284 struct dentry *dentry, const char *target) 285{ 286 struct jffs2_inode_info *f, *dir_f; 287 struct jffs2_sb_info *c; 288 struct inode *inode; 289 struct jffs2_raw_inode *ri; 290 struct jffs2_raw_dirent *rd; 291 struct jffs2_full_dnode *fn; 292 struct jffs2_full_dirent *fd; 293 int namelen; 294 uint32_t alloclen; 295 int ret, targetlen = strlen(target); 296 297 /* FIXME: If you care. We'd need to use frags for the target 298 if it grows much more than this */ 299 if (targetlen > 254) 300 return -ENAMETOOLONG; 301 302 ri = jffs2_alloc_raw_inode(); 303 304 if (!ri) 305 return -ENOMEM; 306 307 c = JFFS2_SB_INFO(dir_i->i_sb); 308 309 /* Try to reserve enough space for both node and dirent. 310 * Just the node will do for now, though 311 */ 312 namelen = dentry->d_name.len; 313 ret = jffs2_reserve_space(c, sizeof(*ri) + targetlen, &alloclen, 314 ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE); 315 316 if (ret) { 317 jffs2_free_raw_inode(ri); 318 return ret; 319 } 320 321 inode = jffs2_new_inode(dir_i, S_IFLNK | S_IRWXUGO, ri); 322 323 if (IS_ERR(inode)) { 324 jffs2_free_raw_inode(ri); 325 jffs2_complete_reservation(c); 326 return PTR_ERR(inode); 327 } 328 329 inode->i_op = &jffs2_symlink_inode_operations; 330 331 f = JFFS2_INODE_INFO(inode); 332 333 inode->i_size = targetlen; 334 ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size); 335 ri->totlen = cpu_to_je32(sizeof(*ri) + inode->i_size); 336 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 337 338 ri->compr = JFFS2_COMPR_NONE; 339 ri->data_crc = cpu_to_je32(crc32(0, target, targetlen)); 340 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 341 342 fn = jffs2_write_dnode(c, f, ri, target, targetlen, ALLOC_NORMAL); 343 344 jffs2_free_raw_inode(ri); 345 346 if (IS_ERR(fn)) { 347 /* Eeek. Wave bye bye */ 348 mutex_unlock(&f->sem); 349 jffs2_complete_reservation(c); 350 ret = PTR_ERR(fn); 351 goto fail; 352 } 353 354 /* We use f->target field to store the target path. */ 355 f->target = kmemdup(target, targetlen + 1, GFP_KERNEL); 356 if (!f->target) { 357 pr_warn("Can't allocate %d bytes of memory\n", targetlen + 1); 358 mutex_unlock(&f->sem); 359 jffs2_complete_reservation(c); 360 ret = -ENOMEM; 361 goto fail; 362 } 363 inode->i_link = f->target; 364 365 jffs2_dbg(1, "%s(): symlink's target '%s' cached\n", 366 __func__, (char *)f->target); 367 368 /* No data here. Only a metadata node, which will be 369 obsoleted by the first data write 370 */ 371 f->metadata = fn; 372 mutex_unlock(&f->sem); 373 374 jffs2_complete_reservation(c); 375 376 ret = jffs2_init_security(inode, dir_i, &dentry->d_name); 377 if (ret) 378 goto fail; 379 380 ret = jffs2_init_acl_post(inode); 381 if (ret) 382 goto fail; 383 384 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 385 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 386 if (ret) 387 goto fail; 388 389 rd = jffs2_alloc_raw_dirent(); 390 if (!rd) { 391 /* Argh. Now we treat it like a normal delete */ 392 jffs2_complete_reservation(c); 393 ret = -ENOMEM; 394 goto fail; 395 } 396 397 dir_f = JFFS2_INODE_INFO(dir_i); 398 mutex_lock(&dir_f->sem); 399 400 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 401 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 402 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 403 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 404 405 rd->pino = cpu_to_je32(dir_i->i_ino); 406 rd->version = cpu_to_je32(++dir_f->highest_version); 407 rd->ino = cpu_to_je32(inode->i_ino); 408 rd->mctime = cpu_to_je32(JFFS2_NOW()); 409 rd->nsize = namelen; 410 rd->type = DT_LNK; 411 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 412 rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen)); 413 414 fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL); 415 416 if (IS_ERR(fd)) { 417 /* dirent failed to write. Delete the inode normally 418 as if it were the final unlink() */ 419 jffs2_complete_reservation(c); 420 jffs2_free_raw_dirent(rd); 421 mutex_unlock(&dir_f->sem); 422 ret = PTR_ERR(fd); 423 goto fail; 424 } 425 426 dir_i->i_mtime = inode_set_ctime_to_ts(dir_i, 427 ITIME(je32_to_cpu(rd->mctime))); 428 429 jffs2_free_raw_dirent(rd); 430 431 /* Link the fd into the inode's list, obsoleting an old 432 one if necessary. */ 433 jffs2_add_fd_to_list(c, fd, &dir_f->dents); 434 435 mutex_unlock(&dir_f->sem); 436 jffs2_complete_reservation(c); 437 438 d_instantiate_new(dentry, inode); 439 return 0; 440 441 fail: 442 iget_failed(inode); 443 return ret; 444} 445 446 447static int jffs2_mkdir (struct mnt_idmap *idmap, struct inode *dir_i, 448 struct dentry *dentry, umode_t mode) 449{ 450 struct jffs2_inode_info *f, *dir_f; 451 struct jffs2_sb_info *c; 452 struct inode *inode; 453 struct jffs2_raw_inode *ri; 454 struct jffs2_raw_dirent *rd; 455 struct jffs2_full_dnode *fn; 456 struct jffs2_full_dirent *fd; 457 int namelen; 458 uint32_t alloclen; 459 int ret; 460 461 mode |= S_IFDIR; 462 463 ri = jffs2_alloc_raw_inode(); 464 if (!ri) 465 return -ENOMEM; 466 467 c = JFFS2_SB_INFO(dir_i->i_sb); 468 469 /* Try to reserve enough space for both node and dirent. 470 * Just the node will do for now, though 471 */ 472 namelen = dentry->d_name.len; 473 ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL, 474 JFFS2_SUMMARY_INODE_SIZE); 475 476 if (ret) { 477 jffs2_free_raw_inode(ri); 478 return ret; 479 } 480 481 inode = jffs2_new_inode(dir_i, mode, ri); 482 483 if (IS_ERR(inode)) { 484 jffs2_free_raw_inode(ri); 485 jffs2_complete_reservation(c); 486 return PTR_ERR(inode); 487 } 488 489 inode->i_op = &jffs2_dir_inode_operations; 490 inode->i_fop = &jffs2_dir_operations; 491 492 f = JFFS2_INODE_INFO(inode); 493 494 /* Directories get nlink 2 at start */ 495 set_nlink(inode, 2); 496 /* but ic->pino_nlink is the parent ino# */ 497 f->inocache->pino_nlink = dir_i->i_ino; 498 499 ri->data_crc = cpu_to_je32(0); 500 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 501 502 fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL); 503 504 jffs2_free_raw_inode(ri); 505 506 if (IS_ERR(fn)) { 507 /* Eeek. Wave bye bye */ 508 mutex_unlock(&f->sem); 509 jffs2_complete_reservation(c); 510 ret = PTR_ERR(fn); 511 goto fail; 512 } 513 /* No data here. Only a metadata node, which will be 514 obsoleted by the first data write 515 */ 516 f->metadata = fn; 517 mutex_unlock(&f->sem); 518 519 jffs2_complete_reservation(c); 520 521 ret = jffs2_init_security(inode, dir_i, &dentry->d_name); 522 if (ret) 523 goto fail; 524 525 ret = jffs2_init_acl_post(inode); 526 if (ret) 527 goto fail; 528 529 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 530 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 531 if (ret) 532 goto fail; 533 534 rd = jffs2_alloc_raw_dirent(); 535 if (!rd) { 536 /* Argh. Now we treat it like a normal delete */ 537 jffs2_complete_reservation(c); 538 ret = -ENOMEM; 539 goto fail; 540 } 541 542 dir_f = JFFS2_INODE_INFO(dir_i); 543 mutex_lock(&dir_f->sem); 544 545 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 546 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 547 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 548 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 549 550 rd->pino = cpu_to_je32(dir_i->i_ino); 551 rd->version = cpu_to_je32(++dir_f->highest_version); 552 rd->ino = cpu_to_je32(inode->i_ino); 553 rd->mctime = cpu_to_je32(JFFS2_NOW()); 554 rd->nsize = namelen; 555 rd->type = DT_DIR; 556 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 557 rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen)); 558 559 fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL); 560 561 if (IS_ERR(fd)) { 562 /* dirent failed to write. Delete the inode normally 563 as if it were the final unlink() */ 564 jffs2_complete_reservation(c); 565 jffs2_free_raw_dirent(rd); 566 mutex_unlock(&dir_f->sem); 567 ret = PTR_ERR(fd); 568 goto fail; 569 } 570 571 dir_i->i_mtime = inode_set_ctime_to_ts(dir_i, 572 ITIME(je32_to_cpu(rd->mctime))); 573 inc_nlink(dir_i); 574 575 jffs2_free_raw_dirent(rd); 576 577 /* Link the fd into the inode's list, obsoleting an old 578 one if necessary. */ 579 jffs2_add_fd_to_list(c, fd, &dir_f->dents); 580 581 mutex_unlock(&dir_f->sem); 582 jffs2_complete_reservation(c); 583 584 d_instantiate_new(dentry, inode); 585 return 0; 586 587 fail: 588 iget_failed(inode); 589 return ret; 590} 591 592static int jffs2_rmdir (struct inode *dir_i, struct dentry *dentry) 593{ 594 struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb); 595 struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); 596 struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(dentry)); 597 struct jffs2_full_dirent *fd; 598 int ret; 599 uint32_t now = JFFS2_NOW(); 600 601 mutex_lock(&f->sem); 602 for (fd = f->dents ; fd; fd = fd->next) { 603 if (fd->ino) { 604 mutex_unlock(&f->sem); 605 return -ENOTEMPTY; 606 } 607 } 608 mutex_unlock(&f->sem); 609 610 ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name, 611 dentry->d_name.len, f, now); 612 if (!ret) { 613 dir_i->i_mtime = inode_set_ctime_to_ts(dir_i, ITIME(now)); 614 clear_nlink(d_inode(dentry)); 615 drop_nlink(dir_i); 616 } 617 return ret; 618} 619 620static int jffs2_mknod (struct mnt_idmap *idmap, struct inode *dir_i, 621 struct dentry *dentry, umode_t mode, dev_t rdev) 622{ 623 struct jffs2_inode_info *f, *dir_f; 624 struct jffs2_sb_info *c; 625 struct inode *inode; 626 struct jffs2_raw_inode *ri; 627 struct jffs2_raw_dirent *rd; 628 struct jffs2_full_dnode *fn; 629 struct jffs2_full_dirent *fd; 630 int namelen; 631 union jffs2_device_node dev; 632 int devlen = 0; 633 uint32_t alloclen; 634 int ret; 635 636 ri = jffs2_alloc_raw_inode(); 637 if (!ri) 638 return -ENOMEM; 639 640 c = JFFS2_SB_INFO(dir_i->i_sb); 641 642 if (S_ISBLK(mode) || S_ISCHR(mode)) 643 devlen = jffs2_encode_dev(&dev, rdev); 644 645 /* Try to reserve enough space for both node and dirent. 646 * Just the node will do for now, though 647 */ 648 namelen = dentry->d_name.len; 649 ret = jffs2_reserve_space(c, sizeof(*ri) + devlen, &alloclen, 650 ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE); 651 652 if (ret) { 653 jffs2_free_raw_inode(ri); 654 return ret; 655 } 656 657 inode = jffs2_new_inode(dir_i, mode, ri); 658 659 if (IS_ERR(inode)) { 660 jffs2_free_raw_inode(ri); 661 jffs2_complete_reservation(c); 662 return PTR_ERR(inode); 663 } 664 inode->i_op = &jffs2_file_inode_operations; 665 init_special_inode(inode, inode->i_mode, rdev); 666 667 f = JFFS2_INODE_INFO(inode); 668 669 ri->dsize = ri->csize = cpu_to_je32(devlen); 670 ri->totlen = cpu_to_je32(sizeof(*ri) + devlen); 671 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 672 673 ri->compr = JFFS2_COMPR_NONE; 674 ri->data_crc = cpu_to_je32(crc32(0, &dev, devlen)); 675 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 676 677 fn = jffs2_write_dnode(c, f, ri, (char *)&dev, devlen, ALLOC_NORMAL); 678 679 jffs2_free_raw_inode(ri); 680 681 if (IS_ERR(fn)) { 682 /* Eeek. Wave bye bye */ 683 mutex_unlock(&f->sem); 684 jffs2_complete_reservation(c); 685 ret = PTR_ERR(fn); 686 goto fail; 687 } 688 /* No data here. Only a metadata node, which will be 689 obsoleted by the first data write 690 */ 691 f->metadata = fn; 692 mutex_unlock(&f->sem); 693 694 jffs2_complete_reservation(c); 695 696 ret = jffs2_init_security(inode, dir_i, &dentry->d_name); 697 if (ret) 698 goto fail; 699 700 ret = jffs2_init_acl_post(inode); 701 if (ret) 702 goto fail; 703 704 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 705 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 706 if (ret) 707 goto fail; 708 709 rd = jffs2_alloc_raw_dirent(); 710 if (!rd) { 711 /* Argh. Now we treat it like a normal delete */ 712 jffs2_complete_reservation(c); 713 ret = -ENOMEM; 714 goto fail; 715 } 716 717 dir_f = JFFS2_INODE_INFO(dir_i); 718 mutex_lock(&dir_f->sem); 719 720 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 721 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 722 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 723 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 724 725 rd->pino = cpu_to_je32(dir_i->i_ino); 726 rd->version = cpu_to_je32(++dir_f->highest_version); 727 rd->ino = cpu_to_je32(inode->i_ino); 728 rd->mctime = cpu_to_je32(JFFS2_NOW()); 729 rd->nsize = namelen; 730 731 /* XXX: This is ugly. */ 732 rd->type = (mode & S_IFMT) >> 12; 733 734 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 735 rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen)); 736 737 fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL); 738 739 if (IS_ERR(fd)) { 740 /* dirent failed to write. Delete the inode normally 741 as if it were the final unlink() */ 742 jffs2_complete_reservation(c); 743 jffs2_free_raw_dirent(rd); 744 mutex_unlock(&dir_f->sem); 745 ret = PTR_ERR(fd); 746 goto fail; 747 } 748 749 dir_i->i_mtime = inode_set_ctime_to_ts(dir_i, 750 ITIME(je32_to_cpu(rd->mctime))); 751 752 jffs2_free_raw_dirent(rd); 753 754 /* Link the fd into the inode's list, obsoleting an old 755 one if necessary. */ 756 jffs2_add_fd_to_list(c, fd, &dir_f->dents); 757 758 mutex_unlock(&dir_f->sem); 759 jffs2_complete_reservation(c); 760 761 d_instantiate_new(dentry, inode); 762 return 0; 763 764 fail: 765 iget_failed(inode); 766 return ret; 767} 768 769static int jffs2_rename (struct mnt_idmap *idmap, 770 struct inode *old_dir_i, struct dentry *old_dentry, 771 struct inode *new_dir_i, struct dentry *new_dentry, 772 unsigned int flags) 773{ 774 int ret; 775 struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dir_i->i_sb); 776 struct jffs2_inode_info *victim_f = NULL; 777 uint8_t type; 778 uint32_t now; 779 780 if (flags & ~RENAME_NOREPLACE) 781 return -EINVAL; 782 783 /* The VFS will check for us and prevent trying to rename a 784 * file over a directory and vice versa, but if it's a directory, 785 * the VFS can't check whether the victim is empty. The filesystem 786 * needs to do that for itself. 787 */ 788 if (d_really_is_positive(new_dentry)) { 789 victim_f = JFFS2_INODE_INFO(d_inode(new_dentry)); 790 if (d_is_dir(new_dentry)) { 791 struct jffs2_full_dirent *fd; 792 793 mutex_lock(&victim_f->sem); 794 for (fd = victim_f->dents; fd; fd = fd->next) { 795 if (fd->ino) { 796 mutex_unlock(&victim_f->sem); 797 return -ENOTEMPTY; 798 } 799 } 800 mutex_unlock(&victim_f->sem); 801 } 802 } 803 804 /* XXX: We probably ought to alloc enough space for 805 both nodes at the same time. Writing the new link, 806 then getting -ENOSPC, is quite bad :) 807 */ 808 809 /* Make a hard link */ 810 811 /* XXX: This is ugly */ 812 type = (d_inode(old_dentry)->i_mode & S_IFMT) >> 12; 813 if (!type) type = DT_REG; 814 815 now = JFFS2_NOW(); 816 ret = jffs2_do_link(c, JFFS2_INODE_INFO(new_dir_i), 817 d_inode(old_dentry)->i_ino, type, 818 new_dentry->d_name.name, new_dentry->d_name.len, now); 819 820 if (ret) 821 return ret; 822 823 if (victim_f) { 824 /* There was a victim. Kill it off nicely */ 825 if (d_is_dir(new_dentry)) 826 clear_nlink(d_inode(new_dentry)); 827 else 828 drop_nlink(d_inode(new_dentry)); 829 /* Don't oops if the victim was a dirent pointing to an 830 inode which didn't exist. */ 831 if (victim_f->inocache) { 832 mutex_lock(&victim_f->sem); 833 if (d_is_dir(new_dentry)) 834 victim_f->inocache->pino_nlink = 0; 835 else 836 victim_f->inocache->pino_nlink--; 837 mutex_unlock(&victim_f->sem); 838 } 839 } 840 841 /* If it was a directory we moved, and there was no victim, 842 increase i_nlink on its new parent */ 843 if (d_is_dir(old_dentry) && !victim_f) 844 inc_nlink(new_dir_i); 845 846 /* Unlink the original */ 847 ret = jffs2_do_unlink(c, JFFS2_INODE_INFO(old_dir_i), 848 old_dentry->d_name.name, old_dentry->d_name.len, NULL, now); 849 850 /* We don't touch inode->i_nlink */ 851 852 if (ret) { 853 /* Oh shit. We really ought to make a single node which can do both atomically */ 854 struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry)); 855 mutex_lock(&f->sem); 856 inc_nlink(d_inode(old_dentry)); 857 if (f->inocache && !d_is_dir(old_dentry)) 858 f->inocache->pino_nlink++; 859 mutex_unlock(&f->sem); 860 861 pr_notice("%s(): Link succeeded, unlink failed (err %d). You now have a hard link\n", 862 __func__, ret); 863 /* 864 * We can't keep the target in dcache after that. 865 * For one thing, we can't afford dentry aliases for directories. 866 * For another, if there was a victim, we _can't_ set new inode 867 * for that sucker and we have to trigger mount eviction - the 868 * caller won't do it on its own since we are returning an error. 869 */ 870 d_invalidate(new_dentry); 871 new_dir_i->i_mtime = inode_set_ctime_to_ts(new_dir_i, 872 ITIME(now)); 873 return ret; 874 } 875 876 if (d_is_dir(old_dentry)) 877 drop_nlink(old_dir_i); 878 879 old_dir_i->i_mtime = inode_set_ctime_to_ts(old_dir_i, ITIME(now)); 880 new_dir_i->i_mtime = inode_set_ctime_to_ts(new_dir_i, ITIME(now)); 881 882 return 0; 883} 884 885