1/* * This file is part of UBIFS. 2 * 3 * Copyright (C) 2006-2008 Nokia Corporation. 4 * Copyright (C) 2006, 2007 University of Szeged, Hungary 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 as published by 8 * the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 13 * more details. 14 * 15 * You should have received a copy of the GNU General Public License along with 16 * this program; if not, write to the Free Software Foundation, Inc., 51 17 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 18 * 19 * Authors: Artem Bityutskiy (���������������� ����������) 20 * Adrian Hunter 21 * Zoltan Sogor 22 */ 23 24/* 25 * This file implements directory operations. 26 * 27 * All FS operations in this file allocate budget before writing anything to the 28 * media. If they fail to allocate it, the error is returned. The only 29 * exceptions are 'ubifs_unlink()' and 'ubifs_rmdir()' which keep working even 30 * if they unable to allocate the budget, because deletion %-ENOSPC failure is 31 * not what users are usually ready to get. UBIFS budgeting subsystem has some 32 * space reserved for these purposes. 33 * 34 * All operations in this file write all inodes which they change straight 35 * away, instead of marking them dirty. For example, 'ubifs_link()' changes 36 * @i_size of the parent inode and writes the parent inode together with the 37 * target inode. This was done to simplify file-system recovery which would 38 * otherwise be very difficult to do. The only exception is rename which marks 39 * the re-named inode dirty (because its @i_ctime is updated) but does not 40 * write it, but just marks it as dirty. 41 */ 42 43#include "ubifs.h" 44 45/** 46 * inherit_flags - inherit flags of the parent inode. 47 * @dir: parent inode 48 * @mode: new inode mode flags 49 * 50 * This is a helper function for 'ubifs_new_inode()' which inherits flag of the 51 * parent directory inode @dir. UBIFS inodes inherit the following flags: 52 * o %UBIFS_COMPR_FL, which is useful to switch compression on/of on 53 * sub-directory basis; 54 * o %UBIFS_SYNC_FL - useful for the same reasons; 55 * o %UBIFS_DIRSYNC_FL - similar, but relevant only to directories. 56 * 57 * This function returns the inherited flags. 58 */ 59static int inherit_flags(const struct inode *dir, umode_t mode) 60{ 61 int flags; 62 const struct ubifs_inode *ui = ubifs_inode(dir); 63 64 if (!S_ISDIR(dir->i_mode)) 65 /* 66 * The parent is not a directory, which means that an extended 67 * attribute inode is being created. No flags. 68 */ 69 return 0; 70 71 flags = ui->flags & (UBIFS_COMPR_FL | UBIFS_SYNC_FL | UBIFS_DIRSYNC_FL); 72 if (!S_ISDIR(mode)) 73 /* The "DIRSYNC" flag only applies to directories */ 74 flags &= ~UBIFS_DIRSYNC_FL; 75 return flags; 76} 77 78/** 79 * ubifs_new_inode - allocate new UBIFS inode object. 80 * @c: UBIFS file-system description object 81 * @dir: parent directory inode 82 * @mode: inode mode flags 83 * 84 * This function finds an unused inode number, allocates new inode and 85 * initializes it. Returns new inode in case of success and an error code in 86 * case of failure. 87 */ 88struct inode *ubifs_new_inode(struct ubifs_info *c, const struct inode *dir, 89 umode_t mode) 90{ 91 struct inode *inode; 92 struct ubifs_inode *ui; 93 94 inode = new_inode(c->vfs_sb); 95 ui = ubifs_inode(inode); 96 if (!inode) 97 return ERR_PTR(-ENOMEM); 98 99 /* 100 * Set 'S_NOCMTIME' to prevent VFS form updating [mc]time of inodes and 101 * marking them dirty in file write path (see 'file_update_time()'). 102 * UBIFS has to fully control "clean <-> dirty" transitions of inodes 103 * to make budgeting work. 104 */ 105 inode->i_flags |= S_NOCMTIME; 106 107 inode_init_owner(inode, dir, mode); 108 inode->i_mtime = inode->i_atime = inode->i_ctime = 109 ubifs_current_time(inode); 110 inode->i_mapping->nrpages = 0; 111 112 switch (mode & S_IFMT) { 113 case S_IFREG: 114 inode->i_mapping->a_ops = &ubifs_file_address_operations; 115 inode->i_op = &ubifs_file_inode_operations; 116 inode->i_fop = &ubifs_file_operations; 117 break; 118 case S_IFDIR: 119 inode->i_op = &ubifs_dir_inode_operations; 120 inode->i_fop = &ubifs_dir_operations; 121 inode->i_size = ui->ui_size = UBIFS_INO_NODE_SZ; 122 break; 123 case S_IFLNK: 124 inode->i_op = &ubifs_symlink_inode_operations; 125 break; 126 case S_IFSOCK: 127 case S_IFIFO: 128 case S_IFBLK: 129 case S_IFCHR: 130 inode->i_op = &ubifs_file_inode_operations; 131 break; 132 default: 133 BUG(); 134 } 135 136 ui->flags = inherit_flags(dir, mode); 137 ubifs_set_inode_flags(inode); 138 if (S_ISREG(mode)) 139 ui->compr_type = c->default_compr; 140 else 141 ui->compr_type = UBIFS_COMPR_NONE; 142 ui->synced_i_size = 0; 143 144 spin_lock(&c->cnt_lock); 145 /* Inode number overflow is currently not supported */ 146 if (c->highest_inum >= INUM_WARN_WATERMARK) { 147 if (c->highest_inum >= INUM_WATERMARK) { 148 spin_unlock(&c->cnt_lock); 149 ubifs_err(c, "out of inode numbers"); 150 make_bad_inode(inode); 151 iput(inode); 152 return ERR_PTR(-EINVAL); 153 } 154 ubifs_warn(c, "running out of inode numbers (current %lu, max %u)", 155 (unsigned long)c->highest_inum, INUM_WATERMARK); 156 } 157 158 inode->i_ino = ++c->highest_inum; 159 /* 160 * The creation sequence number remains with this inode for its 161 * lifetime. All nodes for this inode have a greater sequence number, 162 * and so it is possible to distinguish obsolete nodes belonging to a 163 * previous incarnation of the same inode number - for example, for the 164 * purpose of rebuilding the index. 165 */ 166 ui->creat_sqnum = ++c->max_sqnum; 167 spin_unlock(&c->cnt_lock); 168 return inode; 169} 170 171static int dbg_check_name(const struct ubifs_info *c, 172 const struct ubifs_dent_node *dent, 173 const struct qstr *nm) 174{ 175 if (!dbg_is_chk_gen(c)) 176 return 0; 177 if (le16_to_cpu(dent->nlen) != nm->len) 178 return -EINVAL; 179 if (memcmp(dent->name, nm->name, nm->len)) 180 return -EINVAL; 181 return 0; 182} 183 184static struct dentry *ubifs_lookup(struct inode *dir, struct dentry *dentry, 185 unsigned int flags) 186{ 187 int err; 188 union ubifs_key key; 189 struct inode *inode = NULL; 190 struct ubifs_dent_node *dent; 191 struct ubifs_info *c = dir->i_sb->s_fs_info; 192 193 dbg_gen("'%pd' in dir ino %lu", dentry, dir->i_ino); 194 195 if (dentry->d_name.len > UBIFS_MAX_NLEN) 196 return ERR_PTR(-ENAMETOOLONG); 197 198 dent = kmalloc(UBIFS_MAX_DENT_NODE_SZ, GFP_NOFS); 199 if (!dent) 200 return ERR_PTR(-ENOMEM); 201 202 dent_key_init(c, &key, dir->i_ino, &dentry->d_name); 203 204 err = ubifs_tnc_lookup_nm(c, &key, dent, &dentry->d_name); 205 if (err) { 206 if (err == -ENOENT) { 207 dbg_gen("not found"); 208 goto done; 209 } 210 goto out; 211 } 212 213 if (dbg_check_name(c, dent, &dentry->d_name)) { 214 err = -EINVAL; 215 goto out; 216 } 217 218 inode = ubifs_iget(dir->i_sb, le64_to_cpu(dent->inum)); 219 if (IS_ERR(inode)) { 220 /* 221 * This should not happen. Probably the file-system needs 222 * checking. 223 */ 224 err = PTR_ERR(inode); 225 ubifs_err(c, "dead directory entry '%pd', error %d", 226 dentry, err); 227 ubifs_ro_mode(c, err); 228 goto out; 229 } 230 231done: 232 kfree(dent); 233 /* 234 * Note, d_splice_alias() would be required instead if we supported 235 * NFS. 236 */ 237 d_add(dentry, inode); 238 return NULL; 239 240out: 241 kfree(dent); 242 return ERR_PTR(err); 243} 244 245static int ubifs_create(struct inode *dir, struct dentry *dentry, umode_t mode, 246 bool excl) 247{ 248 struct inode *inode; 249 struct ubifs_info *c = dir->i_sb->s_fs_info; 250 int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len); 251 struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1, 252 .dirtied_ino = 1 }; 253 struct ubifs_inode *dir_ui = ubifs_inode(dir); 254 255 /* 256 * Budget request settings: new inode, new direntry, changing the 257 * parent directory inode. 258 */ 259 260 dbg_gen("dent '%pd', mode %#hx in dir ino %lu", 261 dentry, mode, dir->i_ino); 262 263 err = ubifs_budget_space(c, &req); 264 if (err) 265 return err; 266 267 inode = ubifs_new_inode(c, dir, mode); 268 if (IS_ERR(inode)) { 269 err = PTR_ERR(inode); 270 goto out_budg; 271 } 272 273 err = ubifs_init_security(dir, inode, &dentry->d_name); 274 if (err) 275 goto out_inode; 276 277 mutex_lock(&dir_ui->ui_mutex); 278 dir->i_size += sz_change; 279 dir_ui->ui_size = dir->i_size; 280 dir->i_mtime = dir->i_ctime = inode->i_ctime; 281 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0); 282 if (err) 283 goto out_cancel; 284 mutex_unlock(&dir_ui->ui_mutex); 285 286 ubifs_release_budget(c, &req); 287 insert_inode_hash(inode); 288 d_instantiate(dentry, inode); 289 return 0; 290 291out_cancel: 292 dir->i_size -= sz_change; 293 dir_ui->ui_size = dir->i_size; 294 mutex_unlock(&dir_ui->ui_mutex); 295out_inode: 296 make_bad_inode(inode); 297 iput(inode); 298out_budg: 299 ubifs_release_budget(c, &req); 300 ubifs_err(c, "cannot create regular file, error %d", err); 301 return err; 302} 303 304/** 305 * vfs_dent_type - get VFS directory entry type. 306 * @type: UBIFS directory entry type 307 * 308 * This function converts UBIFS directory entry type into VFS directory entry 309 * type. 310 */ 311static unsigned int vfs_dent_type(uint8_t type) 312{ 313 switch (type) { 314 case UBIFS_ITYPE_REG: 315 return DT_REG; 316 case UBIFS_ITYPE_DIR: 317 return DT_DIR; 318 case UBIFS_ITYPE_LNK: 319 return DT_LNK; 320 case UBIFS_ITYPE_BLK: 321 return DT_BLK; 322 case UBIFS_ITYPE_CHR: 323 return DT_CHR; 324 case UBIFS_ITYPE_FIFO: 325 return DT_FIFO; 326 case UBIFS_ITYPE_SOCK: 327 return DT_SOCK; 328 default: 329 BUG(); 330 } 331 return 0; 332} 333 334/* 335 * The classical Unix view for directory is that it is a linear array of 336 * (name, inode number) entries. Linux/VFS assumes this model as well. 337 * Particularly, 'readdir()' call wants us to return a directory entry offset 338 * which later may be used to continue 'readdir()'ing the directory or to 339 * 'seek()' to that specific direntry. Obviously UBIFS does not really fit this 340 * model because directory entries are identified by keys, which may collide. 341 * 342 * UBIFS uses directory entry hash value for directory offsets, so 343 * 'seekdir()'/'telldir()' may not always work because of possible key 344 * collisions. But UBIFS guarantees that consecutive 'readdir()' calls work 345 * properly by means of saving full directory entry name in the private field 346 * of the file description object. 347 * 348 * This means that UBIFS cannot support NFS which requires full 349 * 'seekdir()'/'telldir()' support. 350 */ 351static int ubifs_readdir(struct file *file, struct dir_context *ctx) 352{ 353 int err; 354 struct qstr nm; 355 union ubifs_key key; 356 struct ubifs_dent_node *dent; 357 struct inode *dir = file_inode(file); 358 struct ubifs_info *c = dir->i_sb->s_fs_info; 359 360 dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, ctx->pos); 361 362 if (ctx->pos > UBIFS_S_KEY_HASH_MASK || ctx->pos == 2) 363 /* 364 * The directory was seek'ed to a senseless position or there 365 * are no more entries. 366 */ 367 return 0; 368 369 if (file->f_version == 0) { 370 /* 371 * The file was seek'ed, which means that @file->private_data 372 * is now invalid. This may also be just the first 373 * 'ubifs_readdir()' invocation, in which case 374 * @file->private_data is NULL, and the below code is 375 * basically a no-op. 376 */ 377 kfree(file->private_data); 378 file->private_data = NULL; 379 } 380 381 /* 382 * 'generic_file_llseek()' unconditionally sets @file->f_version to 383 * zero, and we use this for detecting whether the file was seek'ed. 384 */ 385 file->f_version = 1; 386 387 /* File positions 0 and 1 correspond to "." and ".." */ 388 if (ctx->pos < 2) { 389 ubifs_assert(!file->private_data); 390 if (!dir_emit_dots(file, ctx)) 391 return 0; 392 393 /* Find the first entry in TNC and save it */ 394 lowest_dent_key(c, &key, dir->i_ino); 395 nm.name = NULL; 396 dent = ubifs_tnc_next_ent(c, &key, &nm); 397 if (IS_ERR(dent)) { 398 err = PTR_ERR(dent); 399 goto out; 400 } 401 402 ctx->pos = key_hash_flash(c, &dent->key); 403 file->private_data = dent; 404 } 405 406 dent = file->private_data; 407 if (!dent) { 408 /* 409 * The directory was seek'ed to and is now readdir'ed. 410 * Find the entry corresponding to @ctx->pos or the closest one. 411 */ 412 dent_key_init_hash(c, &key, dir->i_ino, ctx->pos); 413 nm.name = NULL; 414 dent = ubifs_tnc_next_ent(c, &key, &nm); 415 if (IS_ERR(dent)) { 416 err = PTR_ERR(dent); 417 goto out; 418 } 419 ctx->pos = key_hash_flash(c, &dent->key); 420 file->private_data = dent; 421 } 422 423 while (1) { 424 dbg_gen("feed '%s', ino %llu, new f_pos %#x", 425 dent->name, (unsigned long long)le64_to_cpu(dent->inum), 426 key_hash_flash(c, &dent->key)); 427 ubifs_assert(le64_to_cpu(dent->ch.sqnum) > 428 ubifs_inode(dir)->creat_sqnum); 429 430 nm.len = le16_to_cpu(dent->nlen); 431 if (!dir_emit(ctx, dent->name, nm.len, 432 le64_to_cpu(dent->inum), 433 vfs_dent_type(dent->type))) 434 return 0; 435 436 /* Switch to the next entry */ 437 key_read(c, &dent->key, &key); 438 nm.name = dent->name; 439 dent = ubifs_tnc_next_ent(c, &key, &nm); 440 if (IS_ERR(dent)) { 441 err = PTR_ERR(dent); 442 goto out; 443 } 444 445 kfree(file->private_data); 446 ctx->pos = key_hash_flash(c, &dent->key); 447 file->private_data = dent; 448 cond_resched(); 449 } 450 451out: 452 kfree(file->private_data); 453 file->private_data = NULL; 454 455 if (err != -ENOENT) { 456 ubifs_err(c, "cannot find next direntry, error %d", err); 457 return err; 458 } 459 460 /* 2 is a special value indicating that there are no more direntries */ 461 ctx->pos = 2; 462 return 0; 463} 464 465/* Free saved readdir() state when the directory is closed */ 466static int ubifs_dir_release(struct inode *dir, struct file *file) 467{ 468 kfree(file->private_data); 469 file->private_data = NULL; 470 return 0; 471} 472 473/** 474 * lock_2_inodes - a wrapper for locking two UBIFS inodes. 475 * @inode1: first inode 476 * @inode2: second inode 477 * 478 * We do not implement any tricks to guarantee strict lock ordering, because 479 * VFS has already done it for us on the @i_mutex. So this is just a simple 480 * wrapper function. 481 */ 482static void lock_2_inodes(struct inode *inode1, struct inode *inode2) 483{ 484 mutex_lock_nested(&ubifs_inode(inode1)->ui_mutex, WB_MUTEX_1); 485 mutex_lock_nested(&ubifs_inode(inode2)->ui_mutex, WB_MUTEX_2); 486} 487 488/** 489 * unlock_2_inodes - a wrapper for unlocking two UBIFS inodes. 490 * @inode1: first inode 491 * @inode2: second inode 492 */ 493static void unlock_2_inodes(struct inode *inode1, struct inode *inode2) 494{ 495 mutex_unlock(&ubifs_inode(inode2)->ui_mutex); 496 mutex_unlock(&ubifs_inode(inode1)->ui_mutex); 497} 498 499static int ubifs_link(struct dentry *old_dentry, struct inode *dir, 500 struct dentry *dentry) 501{ 502 struct ubifs_info *c = dir->i_sb->s_fs_info; 503 struct inode *inode = d_inode(old_dentry); 504 struct ubifs_inode *ui = ubifs_inode(inode); 505 struct ubifs_inode *dir_ui = ubifs_inode(dir); 506 int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len); 507 struct ubifs_budget_req req = { .new_dent = 1, .dirtied_ino = 2, 508 .dirtied_ino_d = ALIGN(ui->data_len, 8) }; 509 510 /* 511 * Budget request settings: new direntry, changing the target inode, 512 * changing the parent inode. 513 */ 514 515 dbg_gen("dent '%pd' to ino %lu (nlink %d) in dir ino %lu", 516 dentry, inode->i_ino, 517 inode->i_nlink, dir->i_ino); 518 ubifs_assert(mutex_is_locked(&dir->i_mutex)); 519 ubifs_assert(mutex_is_locked(&inode->i_mutex)); 520 521 err = dbg_check_synced_i_size(c, inode); 522 if (err) 523 return err; 524 525 err = ubifs_budget_space(c, &req); 526 if (err) 527 return err; 528 529 lock_2_inodes(dir, inode); 530 inc_nlink(inode); 531 ihold(inode); 532 inode->i_ctime = ubifs_current_time(inode); 533 dir->i_size += sz_change; 534 dir_ui->ui_size = dir->i_size; 535 dir->i_mtime = dir->i_ctime = inode->i_ctime; 536 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0); 537 if (err) 538 goto out_cancel; 539 unlock_2_inodes(dir, inode); 540 541 ubifs_release_budget(c, &req); 542 d_instantiate(dentry, inode); 543 return 0; 544 545out_cancel: 546 dir->i_size -= sz_change; 547 dir_ui->ui_size = dir->i_size; 548 drop_nlink(inode); 549 unlock_2_inodes(dir, inode); 550 ubifs_release_budget(c, &req); 551 iput(inode); 552 return err; 553} 554 555static int ubifs_unlink(struct inode *dir, struct dentry *dentry) 556{ 557 struct ubifs_info *c = dir->i_sb->s_fs_info; 558 struct inode *inode = d_inode(dentry); 559 struct ubifs_inode *dir_ui = ubifs_inode(dir); 560 int sz_change = CALC_DENT_SIZE(dentry->d_name.len); 561 int err, budgeted = 1; 562 struct ubifs_budget_req req = { .mod_dent = 1, .dirtied_ino = 2 }; 563 unsigned int saved_nlink = inode->i_nlink; 564 565 /* 566 * Budget request settings: deletion direntry, deletion inode (+1 for 567 * @dirtied_ino), changing the parent directory inode. If budgeting 568 * fails, go ahead anyway because we have extra space reserved for 569 * deletions. 570 */ 571 572 dbg_gen("dent '%pd' from ino %lu (nlink %d) in dir ino %lu", 573 dentry, inode->i_ino, 574 inode->i_nlink, dir->i_ino); 575 ubifs_assert(mutex_is_locked(&dir->i_mutex)); 576 ubifs_assert(mutex_is_locked(&inode->i_mutex)); 577 err = dbg_check_synced_i_size(c, inode); 578 if (err) 579 return err; 580 581 err = ubifs_budget_space(c, &req); 582 if (err) { 583 if (err != -ENOSPC) 584 return err; 585 budgeted = 0; 586 } 587 588 lock_2_inodes(dir, inode); 589 inode->i_ctime = ubifs_current_time(dir); 590 drop_nlink(inode); 591 dir->i_size -= sz_change; 592 dir_ui->ui_size = dir->i_size; 593 dir->i_mtime = dir->i_ctime = inode->i_ctime; 594 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 1, 0); 595 if (err) 596 goto out_cancel; 597 unlock_2_inodes(dir, inode); 598 599 if (budgeted) 600 ubifs_release_budget(c, &req); 601 else { 602 /* We've deleted something - clean the "no space" flags */ 603 c->bi.nospace = c->bi.nospace_rp = 0; 604 smp_wmb(); 605 } 606 return 0; 607 608out_cancel: 609 dir->i_size += sz_change; 610 dir_ui->ui_size = dir->i_size; 611 set_nlink(inode, saved_nlink); 612 unlock_2_inodes(dir, inode); 613 if (budgeted) 614 ubifs_release_budget(c, &req); 615 return err; 616} 617 618/** 619 * check_dir_empty - check if a directory is empty or not. 620 * @c: UBIFS file-system description object 621 * @dir: VFS inode object of the directory to check 622 * 623 * This function checks if directory @dir is empty. Returns zero if the 624 * directory is empty, %-ENOTEMPTY if it is not, and other negative error codes 625 * in case of of errors. 626 */ 627static int check_dir_empty(struct ubifs_info *c, struct inode *dir) 628{ 629 struct qstr nm = { .name = NULL }; 630 struct ubifs_dent_node *dent; 631 union ubifs_key key; 632 int err; 633 634 lowest_dent_key(c, &key, dir->i_ino); 635 dent = ubifs_tnc_next_ent(c, &key, &nm); 636 if (IS_ERR(dent)) { 637 err = PTR_ERR(dent); 638 if (err == -ENOENT) 639 err = 0; 640 } else { 641 kfree(dent); 642 err = -ENOTEMPTY; 643 } 644 return err; 645} 646 647static int ubifs_rmdir(struct inode *dir, struct dentry *dentry) 648{ 649 struct ubifs_info *c = dir->i_sb->s_fs_info; 650 struct inode *inode = d_inode(dentry); 651 int sz_change = CALC_DENT_SIZE(dentry->d_name.len); 652 int err, budgeted = 1; 653 struct ubifs_inode *dir_ui = ubifs_inode(dir); 654 struct ubifs_budget_req req = { .mod_dent = 1, .dirtied_ino = 2 }; 655 656 /* 657 * Budget request settings: deletion direntry, deletion inode and 658 * changing the parent inode. If budgeting fails, go ahead anyway 659 * because we have extra space reserved for deletions. 660 */ 661 662 dbg_gen("directory '%pd', ino %lu in dir ino %lu", dentry, 663 inode->i_ino, dir->i_ino); 664 ubifs_assert(mutex_is_locked(&dir->i_mutex)); 665 ubifs_assert(mutex_is_locked(&inode->i_mutex)); 666 err = check_dir_empty(c, d_inode(dentry)); 667 if (err) 668 return err; 669 670 err = ubifs_budget_space(c, &req); 671 if (err) { 672 if (err != -ENOSPC) 673 return err; 674 budgeted = 0; 675 } 676 677 lock_2_inodes(dir, inode); 678 inode->i_ctime = ubifs_current_time(dir); 679 clear_nlink(inode); 680 drop_nlink(dir); 681 dir->i_size -= sz_change; 682 dir_ui->ui_size = dir->i_size; 683 dir->i_mtime = dir->i_ctime = inode->i_ctime; 684 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 1, 0); 685 if (err) 686 goto out_cancel; 687 unlock_2_inodes(dir, inode); 688 689 if (budgeted) 690 ubifs_release_budget(c, &req); 691 else { 692 /* We've deleted something - clean the "no space" flags */ 693 c->bi.nospace = c->bi.nospace_rp = 0; 694 smp_wmb(); 695 } 696 return 0; 697 698out_cancel: 699 dir->i_size += sz_change; 700 dir_ui->ui_size = dir->i_size; 701 inc_nlink(dir); 702 set_nlink(inode, 2); 703 unlock_2_inodes(dir, inode); 704 if (budgeted) 705 ubifs_release_budget(c, &req); 706 return err; 707} 708 709static int ubifs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 710{ 711 struct inode *inode; 712 struct ubifs_inode *dir_ui = ubifs_inode(dir); 713 struct ubifs_info *c = dir->i_sb->s_fs_info; 714 int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len); 715 struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1 }; 716 717 /* 718 * Budget request settings: new inode, new direntry and changing parent 719 * directory inode. 720 */ 721 722 dbg_gen("dent '%pd', mode %#hx in dir ino %lu", 723 dentry, mode, dir->i_ino); 724 725 err = ubifs_budget_space(c, &req); 726 if (err) 727 return err; 728 729 inode = ubifs_new_inode(c, dir, S_IFDIR | mode); 730 if (IS_ERR(inode)) { 731 err = PTR_ERR(inode); 732 goto out_budg; 733 } 734 735 err = ubifs_init_security(dir, inode, &dentry->d_name); 736 if (err) 737 goto out_inode; 738 739 mutex_lock(&dir_ui->ui_mutex); 740 insert_inode_hash(inode); 741 inc_nlink(inode); 742 inc_nlink(dir); 743 dir->i_size += sz_change; 744 dir_ui->ui_size = dir->i_size; 745 dir->i_mtime = dir->i_ctime = inode->i_ctime; 746 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0); 747 if (err) { 748 ubifs_err(c, "cannot create directory, error %d", err); 749 goto out_cancel; 750 } 751 mutex_unlock(&dir_ui->ui_mutex); 752 753 ubifs_release_budget(c, &req); 754 d_instantiate(dentry, inode); 755 return 0; 756 757out_cancel: 758 dir->i_size -= sz_change; 759 dir_ui->ui_size = dir->i_size; 760 drop_nlink(dir); 761 mutex_unlock(&dir_ui->ui_mutex); 762out_inode: 763 make_bad_inode(inode); 764 iput(inode); 765out_budg: 766 ubifs_release_budget(c, &req); 767 return err; 768} 769 770static int ubifs_mknod(struct inode *dir, struct dentry *dentry, 771 umode_t mode, dev_t rdev) 772{ 773 struct inode *inode; 774 struct ubifs_inode *ui; 775 struct ubifs_inode *dir_ui = ubifs_inode(dir); 776 struct ubifs_info *c = dir->i_sb->s_fs_info; 777 union ubifs_dev_desc *dev = NULL; 778 int sz_change = CALC_DENT_SIZE(dentry->d_name.len); 779 int err, devlen = 0; 780 struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1, 781 .new_ino_d = ALIGN(devlen, 8), 782 .dirtied_ino = 1 }; 783 784 /* 785 * Budget request settings: new inode, new direntry and changing parent 786 * directory inode. 787 */ 788 789 dbg_gen("dent '%pd' in dir ino %lu", dentry, dir->i_ino); 790 791 if (S_ISBLK(mode) || S_ISCHR(mode)) { 792 dev = kmalloc(sizeof(union ubifs_dev_desc), GFP_NOFS); 793 if (!dev) 794 return -ENOMEM; 795 devlen = ubifs_encode_dev(dev, rdev); 796 } 797 798 err = ubifs_budget_space(c, &req); 799 if (err) { 800 kfree(dev); 801 return err; 802 } 803 804 inode = ubifs_new_inode(c, dir, mode); 805 if (IS_ERR(inode)) { 806 kfree(dev); 807 err = PTR_ERR(inode); 808 goto out_budg; 809 } 810 811 init_special_inode(inode, inode->i_mode, rdev); 812 inode->i_size = ubifs_inode(inode)->ui_size = devlen; 813 ui = ubifs_inode(inode); 814 ui->data = dev; 815 ui->data_len = devlen; 816 817 err = ubifs_init_security(dir, inode, &dentry->d_name); 818 if (err) 819 goto out_inode; 820 821 mutex_lock(&dir_ui->ui_mutex); 822 dir->i_size += sz_change; 823 dir_ui->ui_size = dir->i_size; 824 dir->i_mtime = dir->i_ctime = inode->i_ctime; 825 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0); 826 if (err) 827 goto out_cancel; 828 mutex_unlock(&dir_ui->ui_mutex); 829 830 ubifs_release_budget(c, &req); 831 insert_inode_hash(inode); 832 d_instantiate(dentry, inode); 833 return 0; 834 835out_cancel: 836 dir->i_size -= sz_change; 837 dir_ui->ui_size = dir->i_size; 838 mutex_unlock(&dir_ui->ui_mutex); 839out_inode: 840 make_bad_inode(inode); 841 iput(inode); 842out_budg: 843 ubifs_release_budget(c, &req); 844 return err; 845} 846 847static int ubifs_symlink(struct inode *dir, struct dentry *dentry, 848 const char *symname) 849{ 850 struct inode *inode; 851 struct ubifs_inode *ui; 852 struct ubifs_inode *dir_ui = ubifs_inode(dir); 853 struct ubifs_info *c = dir->i_sb->s_fs_info; 854 int err, len = strlen(symname); 855 int sz_change = CALC_DENT_SIZE(dentry->d_name.len); 856 struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1, 857 .new_ino_d = ALIGN(len, 8), 858 .dirtied_ino = 1 }; 859 860 /* 861 * Budget request settings: new inode, new direntry and changing parent 862 * directory inode. 863 */ 864 865 dbg_gen("dent '%pd', target '%s' in dir ino %lu", dentry, 866 symname, dir->i_ino); 867 868 if (len > UBIFS_MAX_INO_DATA) 869 return -ENAMETOOLONG; 870 871 err = ubifs_budget_space(c, &req); 872 if (err) 873 return err; 874 875 inode = ubifs_new_inode(c, dir, S_IFLNK | S_IRWXUGO); 876 if (IS_ERR(inode)) { 877 err = PTR_ERR(inode); 878 goto out_budg; 879 } 880 881 ui = ubifs_inode(inode); 882 ui->data = kmalloc(len + 1, GFP_NOFS); 883 if (!ui->data) { 884 err = -ENOMEM; 885 goto out_inode; 886 } 887 888 memcpy(ui->data, symname, len); 889 ((char *)ui->data)[len] = '\0'; 890 inode->i_link = ui->data; 891 /* 892 * The terminating zero byte is not written to the flash media and it 893 * is put just to make later in-memory string processing simpler. Thus, 894 * data length is @len, not @len + %1. 895 */ 896 ui->data_len = len; 897 inode->i_size = ubifs_inode(inode)->ui_size = len; 898 899 err = ubifs_init_security(dir, inode, &dentry->d_name); 900 if (err) 901 goto out_inode; 902 903 mutex_lock(&dir_ui->ui_mutex); 904 dir->i_size += sz_change; 905 dir_ui->ui_size = dir->i_size; 906 dir->i_mtime = dir->i_ctime = inode->i_ctime; 907 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0); 908 if (err) 909 goto out_cancel; 910 mutex_unlock(&dir_ui->ui_mutex); 911 912 ubifs_release_budget(c, &req); 913 insert_inode_hash(inode); 914 d_instantiate(dentry, inode); 915 return 0; 916 917out_cancel: 918 dir->i_size -= sz_change; 919 dir_ui->ui_size = dir->i_size; 920 mutex_unlock(&dir_ui->ui_mutex); 921out_inode: 922 make_bad_inode(inode); 923 iput(inode); 924out_budg: 925 ubifs_release_budget(c, &req); 926 return err; 927} 928 929/** 930 * lock_3_inodes - a wrapper for locking three UBIFS inodes. 931 * @inode1: first inode 932 * @inode2: second inode 933 * @inode3: third inode 934 * 935 * This function is used for 'ubifs_rename()' and @inode1 may be the same as 936 * @inode2 whereas @inode3 may be %NULL. 937 * 938 * We do not implement any tricks to guarantee strict lock ordering, because 939 * VFS has already done it for us on the @i_mutex. So this is just a simple 940 * wrapper function. 941 */ 942static void lock_3_inodes(struct inode *inode1, struct inode *inode2, 943 struct inode *inode3) 944{ 945 mutex_lock_nested(&ubifs_inode(inode1)->ui_mutex, WB_MUTEX_1); 946 if (inode2 != inode1) 947 mutex_lock_nested(&ubifs_inode(inode2)->ui_mutex, WB_MUTEX_2); 948 if (inode3) 949 mutex_lock_nested(&ubifs_inode(inode3)->ui_mutex, WB_MUTEX_3); 950} 951 952/** 953 * unlock_3_inodes - a wrapper for unlocking three UBIFS inodes for rename. 954 * @inode1: first inode 955 * @inode2: second inode 956 * @inode3: third inode 957 */ 958static void unlock_3_inodes(struct inode *inode1, struct inode *inode2, 959 struct inode *inode3) 960{ 961 if (inode3) 962 mutex_unlock(&ubifs_inode(inode3)->ui_mutex); 963 if (inode1 != inode2) 964 mutex_unlock(&ubifs_inode(inode2)->ui_mutex); 965 mutex_unlock(&ubifs_inode(inode1)->ui_mutex); 966} 967 968static int ubifs_rename(struct inode *old_dir, struct dentry *old_dentry, 969 struct inode *new_dir, struct dentry *new_dentry) 970{ 971 struct ubifs_info *c = old_dir->i_sb->s_fs_info; 972 struct inode *old_inode = d_inode(old_dentry); 973 struct inode *new_inode = d_inode(new_dentry); 974 struct ubifs_inode *old_inode_ui = ubifs_inode(old_inode); 975 int err, release, sync = 0, move = (new_dir != old_dir); 976 int is_dir = S_ISDIR(old_inode->i_mode); 977 int unlink = !!new_inode; 978 int new_sz = CALC_DENT_SIZE(new_dentry->d_name.len); 979 int old_sz = CALC_DENT_SIZE(old_dentry->d_name.len); 980 struct ubifs_budget_req req = { .new_dent = 1, .mod_dent = 1, 981 .dirtied_ino = 3 }; 982 struct ubifs_budget_req ino_req = { .dirtied_ino = 1, 983 .dirtied_ino_d = ALIGN(old_inode_ui->data_len, 8) }; 984 struct timespec time; 985 unsigned int uninitialized_var(saved_nlink); 986 987 /* 988 * Budget request settings: deletion direntry, new direntry, removing 989 * the old inode, and changing old and new parent directory inodes. 990 * 991 * However, this operation also marks the target inode as dirty and 992 * does not write it, so we allocate budget for the target inode 993 * separately. 994 */ 995 996 dbg_gen("dent '%pd' ino %lu in dir ino %lu to dent '%pd' in dir ino %lu", 997 old_dentry, old_inode->i_ino, old_dir->i_ino, 998 new_dentry, new_dir->i_ino); 999 ubifs_assert(mutex_is_locked(&old_dir->i_mutex)); 1000 ubifs_assert(mutex_is_locked(&new_dir->i_mutex)); 1001 if (unlink) 1002 ubifs_assert(mutex_is_locked(&new_inode->i_mutex)); 1003 1004 1005 if (unlink && is_dir) { 1006 err = check_dir_empty(c, new_inode); 1007 if (err) 1008 return err; 1009 } 1010 1011 err = ubifs_budget_space(c, &req); 1012 if (err) 1013 return err; 1014 err = ubifs_budget_space(c, &ino_req); 1015 if (err) { 1016 ubifs_release_budget(c, &req); 1017 return err; 1018 } 1019 1020 lock_3_inodes(old_dir, new_dir, new_inode); 1021 1022 /* 1023 * Like most other Unix systems, set the @i_ctime for inodes on a 1024 * rename. 1025 */ 1026 time = ubifs_current_time(old_dir); 1027 old_inode->i_ctime = time; 1028 1029 /* We must adjust parent link count when renaming directories */ 1030 if (is_dir) { 1031 if (move) { 1032 /* 1033 * @old_dir loses a link because we are moving 1034 * @old_inode to a different directory. 1035 */ 1036 drop_nlink(old_dir); 1037 /* 1038 * @new_dir only gains a link if we are not also 1039 * overwriting an existing directory. 1040 */ 1041 if (!unlink) 1042 inc_nlink(new_dir); 1043 } else { 1044 /* 1045 * @old_inode is not moving to a different directory, 1046 * but @old_dir still loses a link if we are 1047 * overwriting an existing directory. 1048 */ 1049 if (unlink) 1050 drop_nlink(old_dir); 1051 } 1052 } 1053 1054 old_dir->i_size -= old_sz; 1055 ubifs_inode(old_dir)->ui_size = old_dir->i_size; 1056 old_dir->i_mtime = old_dir->i_ctime = time; 1057 new_dir->i_mtime = new_dir->i_ctime = time; 1058 1059 /* 1060 * And finally, if we unlinked a direntry which happened to have the 1061 * same name as the moved direntry, we have to decrement @i_nlink of 1062 * the unlinked inode and change its ctime. 1063 */ 1064 if (unlink) { 1065 /* 1066 * Directories cannot have hard-links, so if this is a 1067 * directory, just clear @i_nlink. 1068 */ 1069 saved_nlink = new_inode->i_nlink; 1070 if (is_dir) 1071 clear_nlink(new_inode); 1072 else 1073 drop_nlink(new_inode); 1074 new_inode->i_ctime = time; 1075 } else { 1076 new_dir->i_size += new_sz; 1077 ubifs_inode(new_dir)->ui_size = new_dir->i_size; 1078 } 1079 1080 /* 1081 * Do not ask 'ubifs_jnl_rename()' to flush write-buffer if @old_inode 1082 * is dirty, because this will be done later on at the end of 1083 * 'ubifs_rename()'. 1084 */ 1085 if (IS_SYNC(old_inode)) { 1086 sync = IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir); 1087 if (unlink && IS_SYNC(new_inode)) 1088 sync = 1; 1089 } 1090 err = ubifs_jnl_rename(c, old_dir, old_dentry, new_dir, new_dentry, 1091 sync); 1092 if (err) 1093 goto out_cancel; 1094 1095 unlock_3_inodes(old_dir, new_dir, new_inode); 1096 ubifs_release_budget(c, &req); 1097 1098 mutex_lock(&old_inode_ui->ui_mutex); 1099 release = old_inode_ui->dirty; 1100 mark_inode_dirty_sync(old_inode); 1101 mutex_unlock(&old_inode_ui->ui_mutex); 1102 1103 if (release) 1104 ubifs_release_budget(c, &ino_req); 1105 if (IS_SYNC(old_inode)) 1106 err = old_inode->i_sb->s_op->write_inode(old_inode, NULL); 1107 return err; 1108 1109out_cancel: 1110 if (unlink) { 1111 set_nlink(new_inode, saved_nlink); 1112 } else { 1113 new_dir->i_size -= new_sz; 1114 ubifs_inode(new_dir)->ui_size = new_dir->i_size; 1115 } 1116 old_dir->i_size += old_sz; 1117 ubifs_inode(old_dir)->ui_size = old_dir->i_size; 1118 if (is_dir) { 1119 if (move) { 1120 inc_nlink(old_dir); 1121 if (!unlink) 1122 drop_nlink(new_dir); 1123 } else { 1124 if (unlink) 1125 inc_nlink(old_dir); 1126 } 1127 } 1128 unlock_3_inodes(old_dir, new_dir, new_inode); 1129 ubifs_release_budget(c, &ino_req); 1130 ubifs_release_budget(c, &req); 1131 return err; 1132} 1133 1134int ubifs_getattr(struct vfsmount *mnt, struct dentry *dentry, 1135 struct kstat *stat) 1136{ 1137 loff_t size; 1138 struct inode *inode = d_inode(dentry); 1139 struct ubifs_inode *ui = ubifs_inode(inode); 1140 1141 mutex_lock(&ui->ui_mutex); 1142 generic_fillattr(inode, stat); 1143 stat->blksize = UBIFS_BLOCK_SIZE; 1144 stat->size = ui->ui_size; 1145 1146 /* 1147 * Unfortunately, the 'stat()' system call was designed for block 1148 * device based file systems, and it is not appropriate for UBIFS, 1149 * because UBIFS does not have notion of "block". For example, it is 1150 * difficult to tell how many block a directory takes - it actually 1151 * takes less than 300 bytes, but we have to round it to block size, 1152 * which introduces large mistake. This makes utilities like 'du' to 1153 * report completely senseless numbers. This is the reason why UBIFS 1154 * goes the same way as JFFS2 - it reports zero blocks for everything 1155 * but regular files, which makes more sense than reporting completely 1156 * wrong sizes. 1157 */ 1158 if (S_ISREG(inode->i_mode)) { 1159 size = ui->xattr_size; 1160 size += stat->size; 1161 size = ALIGN(size, UBIFS_BLOCK_SIZE); 1162 /* 1163 * Note, user-space expects 512-byte blocks count irrespectively 1164 * of what was reported in @stat->size. 1165 */ 1166 stat->blocks = size >> 9; 1167 } else 1168 stat->blocks = 0; 1169 mutex_unlock(&ui->ui_mutex); 1170 return 0; 1171} 1172 1173const struct inode_operations ubifs_dir_inode_operations = { 1174 .lookup = ubifs_lookup, 1175 .create = ubifs_create, 1176 .link = ubifs_link, 1177 .symlink = ubifs_symlink, 1178 .unlink = ubifs_unlink, 1179 .mkdir = ubifs_mkdir, 1180 .rmdir = ubifs_rmdir, 1181 .mknod = ubifs_mknod, 1182 .rename = ubifs_rename, 1183 .setattr = ubifs_setattr, 1184 .getattr = ubifs_getattr, 1185 .setxattr = ubifs_setxattr, 1186 .getxattr = ubifs_getxattr, 1187 .listxattr = ubifs_listxattr, 1188 .removexattr = ubifs_removexattr, 1189#ifdef CONFIG_UBIFS_ATIME_SUPPORT 1190 .update_time = ubifs_update_time, 1191#endif 1192}; 1193 1194const struct file_operations ubifs_dir_operations = { 1195 .llseek = generic_file_llseek, 1196 .release = ubifs_dir_release, 1197 .read = generic_read_dir, 1198 .iterate = ubifs_readdir, 1199 .fsync = ubifs_fsync, 1200 .unlocked_ioctl = ubifs_ioctl, 1201#ifdef CONFIG_COMPAT 1202 .compat_ioctl = ubifs_compat_ioctl, 1203#endif 1204}; 1205