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