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