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