fs/jffs2/dir.c

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