fs/jffs2/write.c

   1 /*
   2  * JFFS2 -- Journalling Flash File System, Version 2.
   3  *
   4  * Copyright (C) 2001-2003 Red Hat, Inc.
   5  *
   6  * Created by David Woodhouse <dwmw2@infradead.org>
   7  *
   8  * For licensing information, see the file 'LICENCE' in this directory.
   9  *
  10  * $Id: write.c,v 1.91 2005/03/01 10:34:03 dedekind Exp $
  11  *
  12  */
  13
  14 #include <linux/kernel.h>
  15 #include <linux/fs.h>
  16 #include <linux/crc32.h>
  17 #include <linux/slab.h>
  18 #include <linux/pagemap.h>
  19 #include <linux/mtd/mtd.h>
  20 #include "nodelist.h"
  21 #include "compr.h"
  22
  23
  24 int jffs2_do_new_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, uint32_t mode, struct jffs2_raw_inode *ri)
  25 {
  26         struct jffs2_inode_cache *ic;
  27
  28         ic = jffs2_alloc_inode_cache();
  29         if (!ic) {
  30                 return -ENOMEM;
  31         }
  32
  33         memset(ic, 0, sizeof(*ic));
  34
  35         f->inocache = ic;
  36         f->inocache->nlink = 1;
  37         f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache;
  38         f->inocache->ino = ++c->highest_ino;
  39         f->inocache->state = INO_STATE_PRESENT;
  40
  41         ri->ino = cpu_to_je32(f->inocache->ino);
  42
  43         D1(printk(KERN_DEBUG "jffs2_do_new_inode(): Assigned ino# %d\n", f->inocache->ino));
  44         jffs2_add_ino_cache(c, f->inocache);
  45
  46         ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
  47         ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
  48         ri->totlen = cpu_to_je32(PAD(sizeof(*ri)));
  49         ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
  50         ri->mode = cpu_to_jemode(mode);
  51
  52         f->highest_version = 1;
  53         ri->version = cpu_to_je32(f->highest_version);
  54
  55         return 0;
  56 }
  57
  58 #if CONFIG_JFFS2_FS_DEBUG > 0
  59 static void writecheck(struct jffs2_sb_info *c, uint32_t ofs)
  60 {
  61         unsigned char buf[16];
  62         size_t retlen;
  63         int ret, i;
  64
  65         ret = jffs2_flash_read(c, ofs, 16, &retlen, buf);
  66         if (ret || (retlen != 16)) {
  67                 D1(printk(KERN_DEBUG "read failed or short in writecheck(). ret %d, retlen %zd\n", ret, retlen));
  68                 return;
  69         }
  70         ret = 0;
  71         for (i=0; i<16; i++) {
  72                 if (buf[i] != 0xff)
  73                         ret = 1;
  74         }
  75         if (ret) {
  76                 printk(KERN_WARNING "ARGH. About to write node to 0x%08x on flash, but there are data already there:\n", ofs);
  77                 printk(KERN_WARNING "0x%08x: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
  78                        ofs,
  79                        buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7],
  80                        buf[8], buf[9], buf[10], buf[11], buf[12], buf[13], buf[14], buf[15]);
  81         }
  82 }
  83 #endif
  84
  85
  86 /* jffs2_write_dnode - given a raw_inode, allocate a full_dnode for it,
  87    write it to the flash, link it into the existing inode/fragment list */
  88
  89 struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, struct jffs2_raw_inode *ri, const unsigned char *data, uint32_t datalen, uint32_t flash_ofs, int alloc_mode)
  90
  91 {
  92         struct jffs2_raw_node_ref *raw;
  93         struct jffs2_full_dnode *fn;
  94         size_t retlen;
  95         struct kvec vecs[2];
  96         int ret;
  97         int retried = 0;
  98         unsigned long cnt = 2;
  99
 100         D1(if(je32_to_cpu(ri->hdr_crc) != crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)) {
 101                 printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dnode()\n");
 102                 BUG();
 103         }
 104            );
 105         vecs[0].iov_base = ri;
 106         vecs[0].iov_len = sizeof(*ri);
 107         vecs[1].iov_base = (unsigned char *)data;
 108         vecs[1].iov_len = datalen;
 109
 110         D1(writecheck(c, flash_ofs));
 111
 112         if (je32_to_cpu(ri->totlen) != sizeof(*ri) + datalen) {
 113                 printk(KERN_WARNING "jffs2_write_dnode: ri->totlen (0x%08x) != sizeof(*ri) (0x%08zx) + datalen (0x%08x)\n", je32_to_cpu(ri->totlen), sizeof(*ri), datalen);
 114         }
 115         raw = jffs2_alloc_raw_node_ref();
 116         if (!raw)
 117                 return ERR_PTR(-ENOMEM);
 118
 119         fn = jffs2_alloc_full_dnode();
 120         if (!fn) {
 121                 jffs2_free_raw_node_ref(raw);
 122                 return ERR_PTR(-ENOMEM);
 123         }
 124
 125         fn->ofs = je32_to_cpu(ri->offset);
 126         fn->size = je32_to_cpu(ri->dsize);
 127         fn->frags = 0;
 128
 129         /* check number of valid vecs */
 130         if (!datalen || !data)
 131                 cnt = 1;
 132  retry:
 133         fn->raw = raw;
 134
 135         raw->flash_offset = flash_ofs;
 136         raw->__totlen = PAD(sizeof(*ri)+datalen);
 137         raw->next_phys = NULL;
 138
 139         if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(ri->version) < f->highest_version)) {
 140                 BUG_ON(!retried);
 141                 D1(printk(KERN_DEBUG "jffs2_write_dnode : dnode_version %d, "
 142                                 "highest version %d -> updating dnode\n",
 143                                 je32_to_cpu(ri->version), f->highest_version));
 144                 ri->version = cpu_to_je32(++f->highest_version);
 145                 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
 146         }
 147
 148         ret = jffs2_flash_writev(c, vecs, cnt, flash_ofs, &retlen,
 149                                  (alloc_mode==ALLOC_GC)?0:f->inocache->ino);
 150
 151         if (ret || (retlen != sizeof(*ri) + datalen)) {
 152                 printk(KERN_NOTICE "Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
 153                        sizeof(*ri)+datalen, flash_ofs, ret, retlen);
 154
 155                 /* Mark the space as dirtied */
 156                 if (retlen) {
 157                         /* Doesn't belong to any inode */
 158                         raw->next_in_ino = NULL;
 159
 160                         /* Don't change raw->size to match retlen. We may have
 161                            written the node header already, and only the data will
 162                            seem corrupted, in which case the scan would skip over
 163                            any node we write before the original intended end of
 164                            this node */
 165                         raw->flash_offset |= REF_OBSOLETE;
 166                         jffs2_add_physical_node_ref(c, raw);
 167                         jffs2_mark_node_obsolete(c, raw);
 168                 } else {
 169                         printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", raw->flash_offset);
 170                         jffs2_free_raw_node_ref(raw);
 171                 }
 172                 if (!retried && alloc_mode != ALLOC_NORETRY && (raw = jffs2_alloc_raw_node_ref())) {
 173                         /* Try to reallocate space and retry */
 174                         uint32_t dummy;
 175                         struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
 176
 177                         retried = 1;
 178
 179                         D1(printk(KERN_DEBUG "Retrying failed write.\n"));
 180
 181                         ACCT_SANITY_CHECK(c,jeb);
 182                         D1(ACCT_PARANOIA_CHECK(jeb));
 183
 184                         if (alloc_mode == ALLOC_GC) {
 185                                 ret = jffs2_reserve_space_gc(c, sizeof(*ri) + datalen, &flash_ofs, &dummy);
 186                         } else {
 187                                 /* Locking pain */
 188                                 up(&f->sem);
 189                                 jffs2_complete_reservation(c);
 190
 191                                 ret = jffs2_reserve_space(c, sizeof(*ri) + datalen, &flash_ofs, &dummy, alloc_mode);
 192                                 down(&f->sem);
 193                         }
 194
 195                         if (!ret) {
 196                                 D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs));
 197
 198                                 ACCT_SANITY_CHECK(c,jeb);
 199                                 D1(ACCT_PARANOIA_CHECK(jeb));
 200
 201                                 goto retry;
 202                         }
 203                         D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret));
 204                         jffs2_free_raw_node_ref(raw);
 205                 }
 206                 /* Release the full_dnode which is now useless, and return */
 207                 jffs2_free_full_dnode(fn);
 208                 return ERR_PTR(ret?ret:-EIO);
 209         }
 210         /* Mark the space used */
 211         /* If node covers at least a whole page, or if it starts at the
 212            beginning of a page and runs to the end of the file, or if
 213            it's a hole node, mark it REF_PRISTINE, else REF_NORMAL.
 214         */
 215         if ((je32_to_cpu(ri->dsize) >= PAGE_CACHE_SIZE) ||
 216             ( ((je32_to_cpu(ri->offset)&(PAGE_CACHE_SIZE-1))==0) &&
 217               (je32_to_cpu(ri->dsize)+je32_to_cpu(ri->offset) ==  je32_to_cpu(ri->isize)))) {
 218                 raw->flash_offset |= REF_PRISTINE;
 219         } else {
 220                 raw->flash_offset |= REF_NORMAL;
 221         }
 222         jffs2_add_physical_node_ref(c, raw);
 223
 224         /* Link into per-inode list */
 225         spin_lock(&c->erase_completion_lock);
 226         raw->next_in_ino = f->inocache->nodes;
 227         f->inocache->nodes = raw;
 228         spin_unlock(&c->erase_completion_lock);
 229
 230         D1(printk(KERN_DEBUG "jffs2_write_dnode wrote node at 0x%08x(%d) with dsize 0x%x, csize 0x%x, node_crc 0x%08x, data_crc 0x%08x, totlen 0x%08x\n",
 231                   flash_ofs, ref_flags(raw), je32_to_cpu(ri->dsize),
 232                   je32_to_cpu(ri->csize), je32_to_cpu(ri->node_crc),
 233                   je32_to_cpu(ri->data_crc), je32_to_cpu(ri->totlen)));
 234
 235         if (retried) {
 236                 ACCT_SANITY_CHECK(c,NULL);
 237         }
 238
 239         return fn;
 240 }
 241
 242 struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jffs2_inode_info *f, struct jffs2_raw_dirent *rd, const unsigned char *name, uint32_t namelen, uint32_t flash_ofs, int alloc_mode)
 243 {
 244         struct jffs2_raw_node_ref *raw;
 245         struct jffs2_full_dirent *fd;
 246         size_t retlen;
 247         struct kvec vecs[2];
 248         int retried = 0;
 249         int ret;
 250
 251         D1(printk(KERN_DEBUG "jffs2_write_dirent(ino #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x)\n",
 252                   je32_to_cpu(rd->pino), name, name, je32_to_cpu(rd->ino),
 253                   je32_to_cpu(rd->name_crc)));
 254         D1(writecheck(c, flash_ofs));
 255
 256         D1(if(je32_to_cpu(rd->hdr_crc) != crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)) {
 257                 printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dirent()\n");
 258                 BUG();
 259         }
 260            );
 261
 262         vecs[0].iov_base = rd;
 263         vecs[0].iov_len = sizeof(*rd);
 264         vecs[1].iov_base = (unsigned char *)name;
 265         vecs[1].iov_len = namelen;
 266
 267         raw = jffs2_alloc_raw_node_ref();
 268
 269         if (!raw)
 270                 return ERR_PTR(-ENOMEM);
 271
 272         fd = jffs2_alloc_full_dirent(namelen+1);
 273         if (!fd) {
 274                 jffs2_free_raw_node_ref(raw);
 275                 return ERR_PTR(-ENOMEM);
 276         }
 277
 278         fd->version = je32_to_cpu(rd->version);
 279         fd->ino = je32_to_cpu(rd->ino);
 280         fd->nhash = full_name_hash(name, strlen(name));
 281         fd->type = rd->type;
 282         memcpy(fd->name, name, namelen);
 283         fd->name[namelen]=0;
 284
 285  retry:
 286         fd->raw = raw;
 287
 288         raw->flash_offset = flash_ofs;
 289         raw->__totlen = PAD(sizeof(*rd)+namelen);
 290         raw->next_phys = NULL;
 291
 292         if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(rd->version) < f->highest_version)) {
 293                 BUG_ON(!retried);
 294                 D1(printk(KERN_DEBUG "jffs2_write_dirent : dirent_version %d, "
 295                                      "highest version %d -> updating dirent\n",
 296                                      je32_to_cpu(rd->version), f->highest_version));
 297                 rd->version = cpu_to_je32(++f->highest_version);
 298                 fd->version = je32_to_cpu(rd->version);
 299                 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
 300         }
 301
 302         ret = jffs2_flash_writev(c, vecs, 2, flash_ofs, &retlen,
 303                                  (alloc_mode==ALLOC_GC)?0:je32_to_cpu(rd->pino));
 304         if (ret || (retlen != sizeof(*rd) + namelen)) {
 305                 printk(KERN_NOTICE "Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
 306                                sizeof(*rd)+namelen, flash_ofs, ret, retlen);
 307                 /* Mark the space as dirtied */
 308                 if (retlen) {
 309                         raw->next_in_ino = NULL;
 310                         raw->flash_offset |= REF_OBSOLETE;
 311                         jffs2_add_physical_node_ref(c, raw);
 312                         jffs2_mark_node_obsolete(c, raw);
 313                 } else {
 314                         printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", raw->flash_offset);
 315                         jffs2_free_raw_node_ref(raw);
 316                 }
 317                 if (!retried && (raw = jffs2_alloc_raw_node_ref())) {
 318                         /* Try to reallocate space and retry */
 319                         uint32_t dummy;
 320                         struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
 321
 322                         retried = 1;
 323
 324                         D1(printk(KERN_DEBUG "Retrying failed write.\n"));
 325
 326                         ACCT_SANITY_CHECK(c,jeb);
 327                         D1(ACCT_PARANOIA_CHECK(jeb));
 328
 329                         if (alloc_mode == ALLOC_GC) {
 330                                 ret = jffs2_reserve_space_gc(c, sizeof(*rd) + namelen, &flash_ofs, &dummy);
 331                         } else {
 332                                 /* Locking pain */
 333                                 up(&f->sem);
 334                                 jffs2_complete_reservation(c);
 335
 336                                 ret = jffs2_reserve_space(c, sizeof(*rd) + namelen, &flash_ofs, &dummy, alloc_mode);
 337                                 down(&f->sem);
 338                         }
 339
 340                         if (!ret) {
 341                                 D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs));
 342                                 ACCT_SANITY_CHECK(c,jeb);
 343                                 D1(ACCT_PARANOIA_CHECK(jeb));
 344                                 goto retry;
 345                         }
 346                         D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret));
 347                         jffs2_free_raw_node_ref(raw);
 348                 }
 349                 /* Release the full_dnode which is now useless, and return */
 350                 jffs2_free_full_dirent(fd);
 351                 return ERR_PTR(ret?ret:-EIO);
 352         }
 353         /* Mark the space used */
 354         raw->flash_offset |= REF_PRISTINE;
 355         jffs2_add_physical_node_ref(c, raw);
 356
 357         spin_lock(&c->erase_completion_lock);
 358         raw->next_in_ino = f->inocache->nodes;
 359         f->inocache->nodes = raw;
 360         spin_unlock(&c->erase_completion_lock);
 361
 362         if (retried) {
 363                 ACCT_SANITY_CHECK(c,NULL);
 364         }
 365
 366         return fd;
 367 }
 368
 369 /* The OS-specific code fills in the metadata in the jffs2_raw_inode for us, so that
 370    we don't have to go digging in struct inode or its equivalent. It should set:
 371    mode, uid, gid, (starting)isize, atime, ctime, mtime */
 372 int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
 373                             struct jffs2_raw_inode *ri, unsigned char *buf,
 374                             uint32_t offset, uint32_t writelen, uint32_t *retlen)
 375 {
 376         int ret = 0;
 377         uint32_t writtenlen = 0;
 378
 379         D1(printk(KERN_DEBUG "jffs2_write_inode_range(): Ino #%u, ofs 0x%x, len 0x%x\n",
 380                   f->inocache->ino, offset, writelen));
 381
 382         while(writelen) {
 383                 struct jffs2_full_dnode *fn;
 384                 unsigned char *comprbuf = NULL;
 385                 uint16_t comprtype = JFFS2_COMPR_NONE;
 386                 uint32_t phys_ofs, alloclen;
 387                 uint32_t datalen, cdatalen;
 388                 int retried = 0;
 389
 390         retry:
 391                 D2(printk(KERN_DEBUG "jffs2_commit_write() loop: 0x%x to write to 0x%x\n", writelen, offset));
 392
 393                 ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN, &phys_ofs, &alloclen, ALLOC_NORMAL);
 394                 if (ret) {
 395                         D1(printk(KERN_DEBUG "jffs2_reserve_space returned %d\n", ret));
 396                         break;
 397                 }
 398                 down(&f->sem);
 399                 datalen = min_t(uint32_t, writelen, PAGE_CACHE_SIZE - (offset & (PAGE_CACHE_SIZE-1)));
 400                 cdatalen = min_t(uint32_t, alloclen - sizeof(*ri), datalen);
 401
 402                 comprtype = jffs2_compress(c, f, buf, &comprbuf, &datalen, &cdatalen);
 403
 404                 ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
 405                 ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
 406                 ri->totlen = cpu_to_je32(sizeof(*ri) + cdatalen);
 407                 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
 408
 409                 ri->ino = cpu_to_je32(f->inocache->ino);
 410                 ri->version = cpu_to_je32(++f->highest_version);
 411                 ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen));
 412                 ri->offset = cpu_to_je32(offset);
 413                 ri->csize = cpu_to_je32(cdatalen);
 414                 ri->dsize = cpu_to_je32(datalen);
 415                 ri->compr = comprtype & 0xff;
 416                 ri->usercompr = (comprtype >> 8 ) & 0xff;
 417                 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
 418                 ri->data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
 419
 420                 fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, phys_ofs, ALLOC_NORETRY);
 421
 422                 jffs2_free_comprbuf(comprbuf, buf);
 423
 424                 if (IS_ERR(fn)) {
 425                         ret = PTR_ERR(fn);
 426                         up(&f->sem);
 427                         jffs2_complete_reservation(c);
 428                         if (!retried) {
 429                                 /* Write error to be retried */
 430                                 retried = 1;
 431                                 D1(printk(KERN_DEBUG "Retrying node write in jffs2_write_inode_range()\n"));
 432                                 goto retry;
 433                         }
 434                         break;
 435                 }
 436                 ret = jffs2_add_full_dnode_to_inode(c, f, fn);
 437                 if (f->metadata) {
 438                         jffs2_mark_node_obsolete(c, f->metadata->raw);
 439                         jffs2_free_full_dnode(f->metadata);
 440                         f->metadata = NULL;
 441                 }
 442                 if (ret) {
 443                         /* Eep */
 444                         D1(printk(KERN_DEBUG "Eep. add_full_dnode_to_inode() failed in commit_write, returned %d\n", ret));
 445                         jffs2_mark_node_obsolete(c, fn->raw);
 446                         jffs2_free_full_dnode(fn);
 447
 448                         up(&f->sem);
 449                         jffs2_complete_reservation(c);
 450                         break;
 451                 }
 452                 up(&f->sem);
 453                 jffs2_complete_reservation(c);
 454                 if (!datalen) {
 455                         printk(KERN_WARNING "Eep. We didn't actually write any data in jffs2_write_inode_range()\n");
 456                         ret = -EIO;
 457                         break;
 458                 }
 459                 D1(printk(KERN_DEBUG "increasing writtenlen by %d\n", datalen));
 460                 writtenlen += datalen;
 461                 offset += datalen;
 462                 writelen -= datalen;
 463                 buf += datalen;
 464         }
 465         *retlen = writtenlen;
 466         return ret;
 467 }
 468
 469 int jffs2_do_create(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, struct jffs2_inode_info *f, struct jffs2_raw_inode *ri, const char *name, int namelen)
 470 {
 471         struct jffs2_raw_dirent *rd;
 472         struct jffs2_full_dnode *fn;
 473         struct jffs2_full_dirent *fd;
 474         uint32_t alloclen, phys_ofs;
 475         int ret;
 476
 477         /* Try to reserve enough space for both node and dirent.
 478          * Just the node will do for now, though
 479          */
 480         ret = jffs2_reserve_space(c, sizeof(*ri), &phys_ofs, &alloclen, ALLOC_NORMAL);
 481         D1(printk(KERN_DEBUG "jffs2_do_create(): reserved 0x%x bytes\n", alloclen));
 482         if (ret) {
 483                 up(&f->sem);
 484                 return ret;
 485         }
 486
 487         ri->data_crc = cpu_to_je32(0);
 488         ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
 489
 490         fn = jffs2_write_dnode(c, f, ri, NULL, 0, phys_ofs, ALLOC_NORMAL);
 491
 492         D1(printk(KERN_DEBUG "jffs2_do_create created file with mode 0x%x\n",
 493                   jemode_to_cpu(ri->mode)));
 494
 495         if (IS_ERR(fn)) {
 496                 D1(printk(KERN_DEBUG "jffs2_write_dnode() failed\n"));
 497                 /* Eeek. Wave bye bye */
 498                 up(&f->sem);
 499                 jffs2_complete_reservation(c);
 500                 return PTR_ERR(fn);
 501         }
 502         /* No data here. Only a metadata node, which will be
 503            obsoleted by the first data write
 504         */
 505         f->metadata = fn;
 506
 507         up(&f->sem);
 508         jffs2_complete_reservation(c);
 509         ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen, ALLOC_NORMAL);
 510
 511         if (ret) {
 512                 /* Eep. */
 513                 D1(printk(KERN_DEBUG "jffs2_reserve_space() for dirent failed\n"));
 514                 return ret;
 515         }
 516
 517         rd = jffs2_alloc_raw_dirent();
 518         if (!rd) {
 519                 /* Argh. Now we treat it like a normal delete */
 520                 jffs2_complete_reservation(c);
 521                 return -ENOMEM;
 522         }
 523
 524         down(&dir_f->sem);
 525
 526         rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
 527         rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
 528         rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
 529         rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
 530
 531         rd->pino = cpu_to_je32(dir_f->inocache->ino);
 532         rd->version = cpu_to_je32(++dir_f->highest_version);
 533         rd->ino = ri->ino;
 534         rd->mctime = ri->ctime;
 535         rd->nsize = namelen;
 536         rd->type = DT_REG;
 537         rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
 538         rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
 539
 540         fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, phys_ofs, ALLOC_NORMAL);
 541
 542         jffs2_free_raw_dirent(rd);
 543
 544         if (IS_ERR(fd)) {
 545                 /* dirent failed to write. Delete the inode normally
 546                    as if it were the final unlink() */
 547                 jffs2_complete_reservation(c);
 548                 up(&dir_f->sem);
 549                 return PTR_ERR(fd);
 550         }
 551
 552         /* Link the fd into the inode's list, obsoleting an old
 553            one if necessary. */
 554         jffs2_add_fd_to_list(c, fd, &dir_f->dents);
 555
 556         jffs2_complete_reservation(c);
 557         up(&dir_f->sem);
 558
 559         return 0;
 560 }
 561
 562
 563 int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f,
 564                     const char *name, int namelen, struct jffs2_inode_info *dead_f)
 565 {
 566         struct jffs2_raw_dirent *rd;
 567         struct jffs2_full_dirent *fd;
 568         uint32_t alloclen, phys_ofs;
 569         int ret;
 570
 571         if (1 /* alternative branch needs testing */ ||
 572             !jffs2_can_mark_obsolete(c)) {
 573                 /* We can't mark stuff obsolete on the medium. We need to write a deletion dirent */
 574
 575                 rd = jffs2_alloc_raw_dirent();
 576                 if (!rd)
 577                         return -ENOMEM;
 578
 579                 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen, ALLOC_DELETION);
 580                 if (ret) {
 581                         jffs2_free_raw_dirent(rd);
 582                         return ret;
 583                 }
 584
 585                 down(&dir_f->sem);
 586
 587                 /* Build a deletion node */
 588                 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
 589                 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
 590                 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
 591                 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
 592
 593                 rd->pino = cpu_to_je32(dir_f->inocache->ino);
 594                 rd->version = cpu_to_je32(++dir_f->highest_version);
 595                 rd->ino = cpu_to_je32(0);
 596                 rd->mctime = cpu_to_je32(get_seconds());
 597                 rd->nsize = namelen;
 598                 rd->type = DT_UNKNOWN;
 599                 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
 600                 rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
 601
 602                 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, phys_ofs, ALLOC_DELETION);
 603
 604                 jffs2_free_raw_dirent(rd);
 605
 606                 if (IS_ERR(fd)) {
 607                         jffs2_complete_reservation(c);
 608                         up(&dir_f->sem);
 609                         return PTR_ERR(fd);
 610                 }
 611
 612                 /* File it. This will mark the old one obsolete. */
 613                 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
 614                 up(&dir_f->sem);
 615         } else {
 616                 struct jffs2_full_dirent **prev = &dir_f->dents;
 617                 uint32_t nhash = full_name_hash(name, namelen);
 618
 619                 down(&dir_f->sem);
 620
 621                 while ((*prev) && (*prev)->nhash <= nhash) {
 622                         if ((*prev)->nhash == nhash &&
 623                             !memcmp((*prev)->name, name, namelen) &&
 624                             !(*prev)->name[namelen]) {
 625                                 struct jffs2_full_dirent *this = *prev;
 626
 627                                 D1(printk(KERN_DEBUG "Marking old dirent node (ino #%u) @%08x obsolete\n",
 628                                           this->ino, ref_offset(this->raw)));
 629
 630                                 *prev = this->next;
 631                                 jffs2_mark_node_obsolete(c, (this->raw));
 632                                 jffs2_free_full_dirent(this);
 633                                 break;
 634                         }
 635                         prev = &((*prev)->next);
 636                 }
 637                 up(&dir_f->sem);
 638         }
 639
 640         /* dead_f is NULL if this was a rename not a real unlink */
 641         /* Also catch the !f->inocache case, where there was a dirent
 642            pointing to an inode which didn't exist. */
 643         if (dead_f && dead_f->inocache) {
 644
 645                 down(&dead_f->sem);
 646
 647                 if (S_ISDIR(OFNI_EDONI_2SFFJ(dead_f)->i_mode)) {
 648                         while (dead_f->dents) {
 649                                 /* There can be only deleted ones */
 650                                 fd = dead_f->dents;
 651
 652                                 dead_f->dents = fd->next;
 653
 654                                 if (fd->ino) {
 655                                         printk(KERN_WARNING "Deleting inode #%u with active dentry \"%s\"->ino #%u\n",
 656                                                dead_f->inocache->ino, fd->name, fd->ino);
 657                                 } else {
 658                                         D1(printk(KERN_DEBUG "Removing deletion dirent for \"%s\" from dir ino #%u\n",
 659                                                 fd->name, dead_f->inocache->ino));
 660                                 }
 661                                 jffs2_mark_node_obsolete(c, fd->raw);
 662                                 jffs2_free_full_dirent(fd);
 663                         }
 664                 }
 665
 666                 dead_f->inocache->nlink--;
 667                 /* NB: Caller must set inode nlink if appropriate */
 668                 up(&dead_f->sem);
 669         }
 670
 671         jffs2_complete_reservation(c);
 672
 673         return 0;
 674 }
 675
 676
 677 int jffs2_do_link (struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, uint32_t ino, uint8_t type, const char *name, int namelen)
 678 {
 679         struct jffs2_raw_dirent *rd;
 680         struct jffs2_full_dirent *fd;
 681         uint32_t alloclen, phys_ofs;
 682         int ret;
 683
 684         rd = jffs2_alloc_raw_dirent();
 685         if (!rd)
 686                 return -ENOMEM;
 687
 688         ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen, ALLOC_NORMAL);
 689         if (ret) {
 690                 jffs2_free_raw_dirent(rd);
 691                 return ret;
 692         }
 693
 694         down(&dir_f->sem);
 695
 696         /* Build a deletion node */
 697         rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
 698         rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
 699         rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
 700         rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
 701
 702         rd->pino = cpu_to_je32(dir_f->inocache->ino);
 703         rd->version = cpu_to_je32(++dir_f->highest_version);
 704         rd->ino = cpu_to_je32(ino);
 705         rd->mctime = cpu_to_je32(get_seconds());
 706         rd->nsize = namelen;
 707
 708         rd->type = type;
 709
 710         rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
 711         rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
 712
 713         fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, phys_ofs, ALLOC_NORMAL);
 714
 715         jffs2_free_raw_dirent(rd);
 716
 717         if (IS_ERR(fd)) {
 718                 jffs2_complete_reservation(c);
 719                 up(&dir_f->sem);
 720                 return PTR_ERR(fd);
 721         }
 722
 723         /* File it. This will mark the old one obsolete. */
 724         jffs2_add_fd_to_list(c, fd, &dir_f->dents);
 725
 726         jffs2_complete_reservation(c);
 727         up(&dir_f->sem);
 728
 729         return 0;
 730 }