fs/jffs2/write.c

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