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