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