git.oblomov.eu Git - linux-2.6/blob - 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         if (IS_ERR(fn->raw)) {
 177                 void *hold_err = fn->raw;
 178                 /* Release the full_dnode which is now useless, and return */
 179                 jffs2_free_full_dnode(fn);
 180                 return ERR_CAST(hold_err);
 181         }
 182         fn->ofs = je32_to_cpu(ri->offset);
 183         fn->size = je32_to_cpu(ri->dsize);
 184         fn->frags = 0;
 185
 186         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",
 187                   flash_ofs & ~3, flash_ofs & 3, je32_to_cpu(ri->dsize),
 188                   je32_to_cpu(ri->csize), je32_to_cpu(ri->node_crc),
 189                   je32_to_cpu(ri->data_crc), je32_to_cpu(ri->totlen)));
 190
 191         if (retried) {
 192                 jffs2_dbg_acct_sanity_check(c,NULL);
 193         }
 194
 195         return fn;
 196 }
 197
 198 struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
 199                                              struct jffs2_raw_dirent *rd, const unsigned char *name,
 200                                              uint32_t namelen, int alloc_mode)
 201 {
 202         struct jffs2_full_dirent *fd;
 203         size_t retlen;
 204         struct kvec vecs[2];
 205         uint32_t flash_ofs;
 206         int retried = 0;
 207         int ret;
 208
 209         D1(printk(KERN_DEBUG "jffs2_write_dirent(ino #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x)\n",
 210                   je32_to_cpu(rd->pino), name, name, je32_to_cpu(rd->ino),
 211                   je32_to_cpu(rd->name_crc)));
 212
 213         D1(if(je32_to_cpu(rd->hdr_crc) != crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)) {
 214                 printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dirent()\n");
 215                 BUG();
 216            });
 217
 218         if (strnlen(name, namelen) != namelen) {
 219                 /* This should never happen, but seems to have done on at least one
 220                    occasion: https://dev.laptop.org/ticket/4184 */
 221                 printk(KERN_CRIT "Error in jffs2_write_dirent() -- name contains zero bytes!\n");
 222                 printk(KERN_CRIT "Directory inode #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x\n",
 223                        je32_to_cpu(rd->pino), name, name, je32_to_cpu(rd->ino),
 224                        je32_to_cpu(rd->name_crc));
 225                 WARN_ON(1);
 226                 return ERR_PTR(-EIO);
 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         fd = jffs2_alloc_full_dirent(namelen+1);
 235         if (!fd)
 236                 return ERR_PTR(-ENOMEM);
 237
 238         fd->version = je32_to_cpu(rd->version);
 239         fd->ino = je32_to_cpu(rd->ino);
 240         fd->nhash = full_name_hash(name, namelen);
 241         fd->type = rd->type;
 242         memcpy(fd->name, name, namelen);
 243         fd->name[namelen]=0;
 244
 245  retry:
 246         flash_ofs = write_ofs(c);
 247
 248         jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len);
 249
 250         if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(rd->version) < f->highest_version)) {
 251                 BUG_ON(!retried);
 252                 D1(printk(KERN_DEBUG "jffs2_write_dirent : dirent_version %d, "
 253                                      "highest version %d -> updating dirent\n",
 254                                      je32_to_cpu(rd->version), f->highest_version));
 255                 rd->version = cpu_to_je32(++f->highest_version);
 256                 fd->version = je32_to_cpu(rd->version);
 257                 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
 258         }
 259
 260         ret = jffs2_flash_writev(c, vecs, 2, flash_ofs, &retlen,
 261                                  (alloc_mode==ALLOC_GC)?0:je32_to_cpu(rd->pino));
 262         if (ret || (retlen != sizeof(*rd) + namelen)) {
 263                 printk(KERN_NOTICE "Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
 264                                sizeof(*rd)+namelen, flash_ofs, ret, retlen);
 265                 /* Mark the space as dirtied */
 266                 if (retlen) {
 267                         jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*rd)+namelen), NULL);
 268                 } else {
 269                         printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", flash_ofs);
 270                 }
 271                 if (!retried) {
 272                         /* Try to reallocate space and retry */
 273                         uint32_t dummy;
 274                         struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
 275
 276                         retried = 1;
 277
 278                         D1(printk(KERN_DEBUG "Retrying failed write.\n"));
 279
 280                         jffs2_dbg_acct_sanity_check(c,jeb);
 281                         jffs2_dbg_acct_paranoia_check(c, jeb);
 282
 283                         if (alloc_mode == ALLOC_GC) {
 284                                 ret = jffs2_reserve_space_gc(c, sizeof(*rd) + namelen, &dummy,
 285                                                              JFFS2_SUMMARY_DIRENT_SIZE(namelen));
 286                         } else {
 287                                 /* Locking pain */
 288                                 up(&f->sem);
 289                                 jffs2_complete_reservation(c);
 290
 291                                 ret = jffs2_reserve_space(c, sizeof(*rd) + namelen, &dummy,
 292                                                           alloc_mode, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
 293                                 down(&f->sem);
 294                         }
 295
 296                         if (!ret) {
 297                                 flash_ofs = write_ofs(c);
 298                                 D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs));
 299                                 jffs2_dbg_acct_sanity_check(c,jeb);
 300                                 jffs2_dbg_acct_paranoia_check(c, jeb);
 301                                 goto retry;
 302                         }
 303                         D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret));
 304                 }
 305                 /* Release the full_dnode which is now useless, and return */
 306                 jffs2_free_full_dirent(fd);
 307                 return ERR_PTR(ret?ret:-EIO);
 308         }
 309         /* Mark the space used */
 310         fd->raw = jffs2_add_physical_node_ref(c, flash_ofs | dirent_node_state(rd),
 311                                               PAD(sizeof(*rd)+namelen), f->inocache);
 312         if (IS_ERR(fd->raw)) {
 313                 void *hold_err = fd->raw;
 314                 /* Release the full_dirent which is now useless, and return */
 315                 jffs2_free_full_dirent(fd);
 316                 return ERR_CAST(hold_err);
 317         }
 318
 319         if (retried) {
 320                 jffs2_dbg_acct_sanity_check(c,NULL);
 321         }
 322
 323         return fd;
 324 }
 325
 326 /* The OS-specific code fills in the metadata in the jffs2_raw_inode for us, so that
 327    we don't have to go digging in struct inode or its equivalent. It should set:
 328    mode, uid, gid, (starting)isize, atime, ctime, mtime */
 329 int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
 330                             struct jffs2_raw_inode *ri, unsigned char *buf,
 331                             uint32_t offset, uint32_t writelen, uint32_t *retlen)
 332 {
 333         int ret = 0;
 334         uint32_t writtenlen = 0;
 335
 336         D1(printk(KERN_DEBUG "jffs2_write_inode_range(): Ino #%u, ofs 0x%x, len 0x%x\n",
 337                   f->inocache->ino, offset, writelen));
 338
 339         while(writelen) {
 340                 struct jffs2_full_dnode *fn;
 341                 unsigned char *comprbuf = NULL;
 342                 uint16_t comprtype = JFFS2_COMPR_NONE;
 343                 uint32_t alloclen;
 344                 uint32_t datalen, cdatalen;
 345                 int retried = 0;
 346
 347         retry:
 348                 D2(printk(KERN_DEBUG "jffs2_commit_write() loop: 0x%x to write to 0x%x\n", writelen, offset));
 349
 350                 ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN,
 351                                         &alloclen, ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
 352                 if (ret) {
 353                         D1(printk(KERN_DEBUG "jffs2_reserve_space returned %d\n", ret));
 354                         break;
 355                 }
 356                 down(&f->sem);
 357                 datalen = min_t(uint32_t, writelen, PAGE_CACHE_SIZE - (offset & (PAGE_CACHE_SIZE-1)));
 358                 cdatalen = min_t(uint32_t, alloclen - sizeof(*ri), datalen);
 359
 360                 comprtype = jffs2_compress(c, f, buf, &comprbuf, &datalen, &cdatalen);
 361
 362                 ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
 363                 ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
 364                 ri->totlen = cpu_to_je32(sizeof(*ri) + cdatalen);
 365                 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
 366
 367                 ri->ino = cpu_to_je32(f->inocache->ino);
 368                 ri->version = cpu_to_je32(++f->highest_version);
 369                 ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen));
 370                 ri->offset = cpu_to_je32(offset);
 371                 ri->csize = cpu_to_je32(cdatalen);
 372                 ri->dsize = cpu_to_je32(datalen);
 373                 ri->compr = comprtype & 0xff;
 374                 ri->usercompr = (comprtype >> 8 ) & 0xff;
 375                 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
 376                 ri->data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
 377
 378                 fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, ALLOC_NORETRY);
 379
 380                 jffs2_free_comprbuf(comprbuf, buf);
 381
 382                 if (IS_ERR(fn)) {
 383                         ret = PTR_ERR(fn);
 384                         up(&f->sem);
 385                         jffs2_complete_reservation(c);
 386                         if (!retried) {
 387                                 /* Write error to be retried */
 388                                 retried = 1;
 389                                 D1(printk(KERN_DEBUG "Retrying node write in jffs2_write_inode_range()\n"));
 390                                 goto retry;
 391                         }
 392                         break;
 393                 }
 394                 ret = jffs2_add_full_dnode_to_inode(c, f, fn);
 395                 if (f->metadata) {
 396                         jffs2_mark_node_obsolete(c, f->metadata->raw);
 397                         jffs2_free_full_dnode(f->metadata);
 398                         f->metadata = NULL;
 399                 }
 400                 if (ret) {
 401                         /* Eep */
 402                         D1(printk(KERN_DEBUG "Eep. add_full_dnode_to_inode() failed in commit_write, returned %d\n", ret));
 403                         jffs2_mark_node_obsolete(c, fn->raw);
 404                         jffs2_free_full_dnode(fn);
 405
 406                         up(&f->sem);
 407                         jffs2_complete_reservation(c);
 408                         break;
 409                 }
 410                 up(&f->sem);
 411                 jffs2_complete_reservation(c);
 412                 if (!datalen) {
 413                         printk(KERN_WARNING "Eep. We didn't actually write any data in jffs2_write_inode_range()\n");
 414                         ret = -EIO;
 415                         break;
 416                 }
 417                 D1(printk(KERN_DEBUG "increasing writtenlen by %d\n", datalen));
 418                 writtenlen += datalen;
 419                 offset += datalen;
 420                 writelen -= datalen;
 421                 buf += datalen;
 422         }
 423         *retlen = writtenlen;
 424         return ret;
 425 }
 426
 427 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)
 428 {
 429         struct jffs2_raw_dirent *rd;
 430         struct jffs2_full_dnode *fn;
 431         struct jffs2_full_dirent *fd;
 432         uint32_t alloclen;
 433         int ret;
 434
 435         /* Try to reserve enough space for both node and dirent.
 436          * Just the node will do for now, though
 437          */
 438         ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL,
 439                                 JFFS2_SUMMARY_INODE_SIZE);
 440         D1(printk(KERN_DEBUG "jffs2_do_create(): reserved 0x%x bytes\n", alloclen));
 441         if (ret) {
 442                 up(&f->sem);
 443                 return ret;
 444         }
 445
 446         ri->data_crc = cpu_to_je32(0);
 447         ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
 448
 449         fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL);
 450
 451         D1(printk(KERN_DEBUG "jffs2_do_create created file with mode 0x%x\n",
 452                   jemode_to_cpu(ri->mode)));
 453
 454         if (IS_ERR(fn)) {
 455                 D1(printk(KERN_DEBUG "jffs2_write_dnode() failed\n"));
 456                 /* Eeek. Wave bye bye */
 457                 up(&f->sem);
 458                 jffs2_complete_reservation(c);
 459                 return PTR_ERR(fn);
 460         }
 461         /* No data here. Only a metadata node, which will be
 462            obsoleted by the first data write
 463         */
 464         f->metadata = fn;
 465
 466         up(&f->sem);
 467         jffs2_complete_reservation(c);
 468
 469         ret = jffs2_init_security(&f->vfs_inode, &dir_f->vfs_inode);
 470         if (ret)
 471                 return ret;
 472         ret = jffs2_init_acl_post(&f->vfs_inode);
 473         if (ret)
 474                 return ret;
 475
 476         ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
 477                                 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
 478
 479         if (ret) {
 480                 /* Eep. */
 481                 D1(printk(KERN_DEBUG "jffs2_reserve_space() for dirent failed\n"));
 482                 return ret;
 483         }
 484
 485         rd = jffs2_alloc_raw_dirent();
 486         if (!rd) {
 487                 /* Argh. Now we treat it like a normal delete */
 488                 jffs2_complete_reservation(c);
 489                 return -ENOMEM;
 490         }
 491
 492         down(&dir_f->sem);
 493
 494         rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
 495         rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
 496         rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
 497         rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
 498
 499         rd->pino = cpu_to_je32(dir_f->inocache->ino);
 500         rd->version = cpu_to_je32(++dir_f->highest_version);
 501         rd->ino = ri->ino;
 502         rd->mctime = ri->ctime;
 503         rd->nsize = namelen;
 504         rd->type = DT_REG;
 505         rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
 506         rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
 507
 508         fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL);
 509
 510         jffs2_free_raw_dirent(rd);
 511
 512         if (IS_ERR(fd)) {
 513                 /* dirent failed to write. Delete the inode normally
 514                    as if it were the final unlink() */
 515                 jffs2_complete_reservation(c);
 516                 up(&dir_f->sem);
 517                 return PTR_ERR(fd);
 518         }
 519
 520         /* Link the fd into the inode's list, obsoleting an old
 521            one if necessary. */
 522         jffs2_add_fd_to_list(c, fd, &dir_f->dents);
 523
 524         jffs2_complete_reservation(c);
 525         up(&dir_f->sem);
 526
 527         return 0;
 528 }
 529
 530
 531 int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f,
 532                     const char *name, int namelen, struct jffs2_inode_info *dead_f,
 533                     uint32_t time)
 534 {
 535         struct jffs2_raw_dirent *rd;
 536         struct jffs2_full_dirent *fd;
 537         uint32_t alloclen;
 538         int ret;
 539
 540         if (!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 *fd = dir_f->dents;
 586                 uint32_t nhash = full_name_hash(name, namelen);
 587
 588                 /* We don't actually want to reserve any space, but we do
 589                    want to be holding the alloc_sem when we write to flash */
 590                 down(&c->alloc_sem);
 591                 down(&dir_f->sem);
 592
 593                 for (fd = dir_f->dents; fd; fd = fd->next) {
 594                         if (fd->nhash == nhash &&
 595                             !memcmp(fd->name, name, namelen) &&
 596                             !fd->name[namelen]) {
 597
 598                                 D1(printk(KERN_DEBUG "Marking old dirent node (ino #%u) @%08x obsolete\n",
 599                                           fd->ino, ref_offset(fd->raw)));
 600                                 jffs2_mark_node_obsolete(c, fd->raw);
 601                                 /* We don't want to remove it from the list immediately,
 602                                    because that screws up getdents()/seek() semantics even
 603                                    more than they're screwed already. Turn it into a
 604                                    node-less deletion dirent instead -- a placeholder */
 605                                 fd->raw = NULL;
 606                                 fd->ino = 0;
 607                                 break;
 608                         }
 609                 }
 610                 up(&dir_f->sem);
 611         }
 612
 613         /* dead_f is NULL if this was a rename not a real unlink */
 614         /* Also catch the !f->inocache case, where there was a dirent
 615            pointing to an inode which didn't exist. */
 616         if (dead_f && dead_f->inocache) {
 617
 618                 down(&dead_f->sem);
 619
 620                 if (S_ISDIR(OFNI_EDONI_2SFFJ(dead_f)->i_mode)) {
 621                         while (dead_f->dents) {
 622                                 /* There can be only deleted ones */
 623                                 fd = dead_f->dents;
 624
 625                                 dead_f->dents = fd->next;
 626
 627                                 if (fd->ino) {
 628                                         printk(KERN_WARNING "Deleting inode #%u with active dentry \"%s\"->ino #%u\n",
 629                                                dead_f->inocache->ino, fd->name, fd->ino);
 630                                 } else {
 631                                         D1(printk(KERN_DEBUG "Removing deletion dirent for \"%s\" from dir ino #%u\n",
 632                                                 fd->name, dead_f->inocache->ino));
 633                                 }
 634                                 if (fd->raw)
 635                                         jffs2_mark_node_obsolete(c, fd->raw);
 636                                 jffs2_free_full_dirent(fd);
 637                         }
 638                 }
 639
 640                 dead_f->inocache->nlink--;
 641                 /* NB: Caller must set inode nlink if appropriate */
 642                 up(&dead_f->sem);
 643         }
 644
 645         jffs2_complete_reservation(c);
 646
 647         return 0;
 648 }
 649
 650
 651 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)
 652 {
 653         struct jffs2_raw_dirent *rd;
 654         struct jffs2_full_dirent *fd;
 655         uint32_t alloclen;
 656         int ret;
 657
 658         rd = jffs2_alloc_raw_dirent();
 659         if (!rd)
 660                 return -ENOMEM;
 661
 662         ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
 663                                 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
 664         if (ret) {
 665                 jffs2_free_raw_dirent(rd);
 666                 return ret;
 667         }
 668
 669         down(&dir_f->sem);
 670
 671         /* Build a deletion node */
 672         rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
 673         rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
 674         rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
 675         rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
 676
 677         rd->pino = cpu_to_je32(dir_f->inocache->ino);
 678         rd->version = cpu_to_je32(++dir_f->highest_version);
 679         rd->ino = cpu_to_je32(ino);
 680         rd->mctime = cpu_to_je32(time);
 681         rd->nsize = namelen;
 682
 683         rd->type = type;
 684
 685         rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
 686         rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
 687
 688         fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL);
 689
 690         jffs2_free_raw_dirent(rd);
 691
 692         if (IS_ERR(fd)) {
 693                 jffs2_complete_reservation(c);
 694                 up(&dir_f->sem);
 695                 return PTR_ERR(fd);
 696         }
 697
 698         /* File it. This will mark the old one obsolete. */
 699         jffs2_add_fd_to_list(c, fd, &dir_f->dents);
 700
 701         jffs2_complete_reservation(c);
 702         up(&dir_f->sem);
 703
 704         return 0;
 705 }