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