fs/jffs2/write.c

   1 /*
   2  * JFFS2 -- Journalling Flash File System, Version 2.
   3  *
   4  * Copyright (C) 2001, 2002 Red Hat, Inc.
   5  *
   6  * Created by David Woodhouse <dwmw2@cambridge.redhat.com>
   7  *
   8  * For licensing information, see the file 'LICENCE' in this directory.
   9  *
  10  * $Id: write.c,v 1.56 2002/07/10 14:05:16 dwmw2 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/mtd/mtd.h>
  19 #include "nodelist.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         init_MUTEX_LOCKED(&f->sem);
  34         f->inocache = ic;
  35         f->inocache->nlink = 1;
  36         f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache;
  37         f->inocache->ino = ri->ino =  ++c->highest_ino;
  38         D1(printk(KERN_DEBUG "jffs2_do_new_inode(): Assigned ino# %d\n", ri->ino));
  39         jffs2_add_ino_cache(c, f->inocache);
  40
  41         ri->magic = JFFS2_MAGIC_BITMASK;
  42         ri->nodetype = JFFS2_NODETYPE_INODE;
  43         ri->totlen = PAD(sizeof(*ri));
  44         ri->hdr_crc = crc32(0, ri, sizeof(struct jffs2_unknown_node)-4);
  45         ri->mode = mode;
  46         f->highest_version = ri->version = 1;
  47
  48         return 0;
  49 }
  50
  51 static void writecheck(struct jffs2_sb_info *c, uint32_t ofs)
  52 {
  53         unsigned char buf[16];
  54         size_t retlen;
  55         int ret, i;
  56
  57         ret = jffs2_flash_read(c, ofs, 16, &retlen, buf);
  58         if (ret || (retlen != 16)) {
  59                 D1(printk(KERN_DEBUG "read failed or short in writecheck(). ret %d, retlen %d\n", ret, retlen));
  60                 return;
  61         }
  62         ret = 0;
  63         for (i=0; i<16; i++) {
  64                 if (buf[i] != 0xff)
  65                         ret = 1;
  66         }
  67         if (ret) {
  68                 printk(KERN_WARNING "ARGH. About to write node to 0x%08x on flash, but there are data already there:\n", ofs);
  69                 printk(KERN_WARNING "0x%08x: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
  70                        ofs,
  71                        buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7],
  72                        buf[8], buf[9], buf[10], buf[11], buf[12], buf[13], buf[14], buf[15]);
  73         }
  74 }
  75
  76
  77
  78 /* jffs2_write_dnode - given a raw_inode, allocate a full_dnode for it,
  79    write it to the flash, link it into the existing inode/fragment list */
  80
  81 struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, struct jffs2_raw_inode *ri, const unsigned char *data, uint32_t datalen, uint32_t flash_ofs,  uint32_t *writelen)
  82
  83 {
  84         struct jffs2_raw_node_ref *raw;
  85         struct jffs2_full_dnode *fn;
  86         size_t retlen;
  87         struct iovec vecs[2];
  88         int ret;
  89         unsigned long cnt = 2;
  90
  91         D1(if(ri->hdr_crc != crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)) {
  92                 printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dnode()\n");
  93                 BUG();
  94         }
  95            );
  96         vecs[0].iov_base = ri;
  97         vecs[0].iov_len = sizeof(*ri);
  98         vecs[1].iov_base = (unsigned char *)data;
  99         vecs[1].iov_len = datalen;
 100
 101         writecheck(c, flash_ofs);
 102
 103         if (ri->totlen != sizeof(*ri) + datalen) {
 104                 printk(KERN_WARNING "jffs2_write_dnode: ri->totlen (0x%08x) != sizeof(*ri) (0x%08x) + datalen (0x%08x)\n", ri->totlen, sizeof(*ri), datalen);
 105         }
 106         raw = jffs2_alloc_raw_node_ref();
 107         if (!raw)
 108                 return ERR_PTR(-ENOMEM);
 109
 110         fn = jffs2_alloc_full_dnode();
 111         if (!fn) {
 112                 jffs2_free_raw_node_ref(raw);
 113                 return ERR_PTR(-ENOMEM);
 114         }
 115         raw->flash_offset = flash_ofs;
 116         raw->totlen = PAD(ri->totlen);
 117         raw->next_phys = NULL;
 118
 119         fn->ofs = ri->offset;
 120         fn->size = ri->dsize;
 121         fn->frags = 0;
 122         fn->raw = raw;
 123
 124         /* check number of valid vecs */
 125         if (!datalen || !data)
 126                 cnt = 1;
 127
 128         ret = jffs2_flash_writev(c, vecs, cnt, flash_ofs, &retlen);
 129
 130         if (ret || (retlen != sizeof(*ri) + datalen)) {
 131                 printk(KERN_NOTICE "Write of %d bytes at 0x%08x failed. returned %d, retlen %d\n",
 132                        sizeof(*ri)+datalen, flash_ofs, ret, retlen);
 133                 /* Mark the space as dirtied */
 134                 if (retlen) {
 135                         /* Doesn't belong to any inode */
 136                         raw->next_in_ino = NULL;
 137
 138                         /* Don't change raw->size to match retlen. We may have
 139                            written the node header already, and only the data will
 140                            seem corrupted, in which case the scan would skip over
 141                            any node we write before the original intended end of
 142                            this node */
 143                         jffs2_add_physical_node_ref(c, raw, sizeof(*ri)+datalen, 1);
 144                         jffs2_mark_node_obsolete(c, raw);
 145                 } else {
 146                         printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", raw->flash_offset);
 147                         jffs2_free_raw_node_ref(raw);
 148                 }
 149
 150                 /* Release the full_dnode which is now useless, and return */
 151                 jffs2_free_full_dnode(fn);
 152                 if (writelen)
 153                         *writelen = retlen;
 154                 return ERR_PTR(ret?ret:-EIO);
 155         }
 156         /* Mark the space used */
 157         jffs2_add_physical_node_ref(c, raw, retlen, 0);
 158
 159         /* Link into per-inode list */
 160         raw->next_in_ino = f->inocache->nodes;
 161         f->inocache->nodes = raw;
 162
 163         D1(printk(KERN_DEBUG "jffs2_write_dnode wrote node at 0x%08x with dsize 0x%x, csize 0x%x, node_crc 0x%08x, data_crc 0x%08x, totlen 0x%08x\n", flash_ofs, ri->dsize, ri->csize, ri->node_crc, ri->data_crc, ri->totlen));
 164         if (writelen)
 165                 *writelen = retlen;
 166
 167         f->inocache->nodes = raw;
 168         return fn;
 169 }
 170
 171 struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jffs2_inode_info *f, struct jffs2_raw_dirent *rd, const unsigned char *name, uint32_t namelen, uint32_t flash_ofs,  uint32_t *writelen)
 172 {
 173         struct jffs2_raw_node_ref *raw;
 174         struct jffs2_full_dirent *fd;
 175         size_t retlen;
 176         struct iovec vecs[2];
 177         int ret;
 178
 179         D1(printk(KERN_DEBUG "jffs2_write_dirent(ino #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x)\n", rd->pino, name, name, rd->ino, rd->name_crc));
 180         writecheck(c, flash_ofs);
 181
 182         D1(if(rd->hdr_crc != crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)) {
 183                 printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dirent()\n");
 184                 BUG();
 185         }
 186            );
 187
 188         vecs[0].iov_base = rd;
 189         vecs[0].iov_len = sizeof(*rd);
 190         vecs[1].iov_base = (unsigned char *)name;
 191         vecs[1].iov_len = namelen;
 192
 193         raw = jffs2_alloc_raw_node_ref();
 194
 195         if (!raw)
 196                 return ERR_PTR(-ENOMEM);
 197
 198         fd = jffs2_alloc_full_dirent(namelen+1);
 199         if (!fd) {
 200                 jffs2_free_raw_node_ref(raw);
 201                 return ERR_PTR(-ENOMEM);
 202         }
 203         raw->flash_offset = flash_ofs;
 204         raw->totlen = PAD(rd->totlen);
 205         raw->next_in_ino = f->inocache->nodes;
 206         f->inocache->nodes = raw;
 207         raw->next_phys = NULL;
 208
 209         fd->version = rd->version;
 210         fd->ino = rd->ino;
 211         fd->nhash = full_name_hash(name, strlen(name));
 212         fd->type = rd->type;
 213         memcpy(fd->name, name, namelen);
 214         fd->name[namelen]=0;
 215         fd->raw = raw;
 216
 217         ret = jffs2_flash_writev(c, vecs, 2, flash_ofs, &retlen);
 218         if (ret || (retlen != sizeof(*rd) + namelen)) {
 219                 printk(KERN_NOTICE "Write of %d bytes at 0x%08x failed. returned %d, retlen %d\n",
 220                                sizeof(*rd)+namelen, flash_ofs, ret, retlen);
 221                 /* Mark the space as dirtied */
 222                 if (retlen) {
 223                         jffs2_add_physical_node_ref(c, raw, sizeof(*rd)+namelen, 1);
 224                         jffs2_mark_node_obsolete(c, raw);
 225                 } else {
 226                         printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", raw->flash_offset);
 227                         jffs2_free_raw_node_ref(raw);
 228                 }
 229
 230                 /* Release the full_dnode which is now useless, and return */
 231                 jffs2_free_full_dirent(fd);
 232                 if (writelen)
 233                         *writelen = retlen;
 234                 return ERR_PTR(ret?ret:-EIO);
 235         }
 236         /* Mark the space used */
 237         jffs2_add_physical_node_ref(c, raw, retlen, 0);
 238         if (writelen)
 239                 *writelen = retlen;
 240
 241         f->inocache->nodes = raw;
 242         return fd;
 243 }
 244
 245 /* The OS-specific code fills in the metadata in the jffs2_raw_inode for us, so that
 246    we don't have to go digging in struct inode or its equivalent. It should set:
 247    mode, uid, gid, (starting)isize, atime, ctime, mtime */
 248 int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
 249                             struct jffs2_raw_inode *ri, unsigned char *buf,
 250                             uint32_t offset, uint32_t writelen, uint32_t *retlen)
 251 {
 252         int ret = 0;
 253         uint32_t writtenlen = 0;
 254
 255         D1(printk(KERN_DEBUG "jffs2_write_inode_range(): Ino #%u, ofs 0x%x, len 0x%x\n",
 256                   f->inocache->ino, offset, writelen));
 257
 258         while(writelen) {
 259                 struct jffs2_full_dnode *fn;
 260                 unsigned char *comprbuf = NULL;
 261                 unsigned char comprtype = JFFS2_COMPR_NONE;
 262                 uint32_t phys_ofs, alloclen;
 263                 uint32_t datalen, cdatalen;
 264
 265                 D2(printk(KERN_DEBUG "jffs2_commit_write() loop: 0x%x to write to 0x%x\n", writelen, offset));
 266
 267                 ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN, &phys_ofs, &alloclen, ALLOC_NORMAL);
 268                 if (ret) {
 269                         D1(printk(KERN_DEBUG "jffs2_reserve_space returned %d\n", ret));
 270                         break;
 271                 }
 272                 down(&f->sem);
 273                 datalen = writelen;
 274                 cdatalen = min(alloclen - sizeof(*ri), writelen);
 275
 276                 comprbuf = kmalloc(cdatalen, GFP_KERNEL);
 277                 if (comprbuf) {
 278                         comprtype = jffs2_compress(buf, comprbuf, &datalen, &cdatalen);
 279                 }
 280                 if (comprtype == JFFS2_COMPR_NONE) {
 281                         /* Either compression failed, or the allocation of comprbuf failed */
 282                         if (comprbuf)
 283                                 kfree(comprbuf);
 284                         comprbuf = buf;
 285                         datalen = cdatalen;
 286                 }
 287                 /* Now comprbuf points to the data to be written, be it compressed or not.
 288                    comprtype holds the compression type, and comprtype == JFFS2_COMPR_NONE means
 289                    that the comprbuf doesn't need to be kfree()d.
 290                 */
 291
 292                 ri->magic = JFFS2_MAGIC_BITMASK;
 293                 ri->nodetype = JFFS2_NODETYPE_INODE;
 294                 ri->totlen = sizeof(*ri) + cdatalen;
 295                 ri->hdr_crc = crc32(0, ri, sizeof(struct jffs2_unknown_node)-4);
 296
 297                 ri->ino = f->inocache->ino;
 298                 ri->version = ++f->highest_version;
 299                 ri->isize = max(ri->isize, offset + datalen);
 300                 ri->offset = offset;
 301                 ri->csize = cdatalen;
 302                 ri->dsize = datalen;
 303                 ri->compr = comprtype;
 304                 ri->node_crc = crc32(0, ri, sizeof(*ri)-8);
 305                 ri->data_crc = crc32(0, comprbuf, cdatalen);
 306
 307                 fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, phys_ofs, NULL);
 308
 309                 if (comprtype != JFFS2_COMPR_NONE)
 310                         kfree(comprbuf);
 311
 312                 if (IS_ERR(fn)) {
 313                         ret = PTR_ERR(fn);
 314                         up(&f->sem);
 315                         jffs2_complete_reservation(c);
 316                         break;
 317                 }
 318                 ret = jffs2_add_full_dnode_to_inode(c, f, fn);
 319                 if (f->metadata) {
 320                         jffs2_mark_node_obsolete(c, f->metadata->raw);
 321                         jffs2_free_full_dnode(f->metadata);
 322                         f->metadata = NULL;
 323                 }
 324                 if (ret) {
 325                         /* Eep */
 326                         D1(printk(KERN_DEBUG "Eep. add_full_dnode_to_inode() failed in commit_write, returned %d\n", ret));
 327                         jffs2_mark_node_obsolete(c, fn->raw);
 328                         jffs2_free_full_dnode(fn);
 329
 330                         up(&f->sem);
 331                         jffs2_complete_reservation(c);
 332                         break;
 333                 }
 334                 up(&f->sem);
 335                 jffs2_complete_reservation(c);
 336                 if (!datalen) {
 337                         printk(KERN_WARNING "Eep. We didn't actually write any data in jffs2_write_inode_range()\n");
 338                         ret = -EIO;
 339                         break;
 340                 }
 341                 D1(printk(KERN_DEBUG "increasing writtenlen by %d\n", datalen));
 342                 writtenlen += datalen;
 343                 offset += datalen;
 344                 writelen -= datalen;
 345                 buf += datalen;
 346         }
 347         *retlen = writtenlen;
 348         return ret;
 349 }
 350
 351 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)
 352 {
 353         struct jffs2_raw_dirent *rd;
 354         struct jffs2_full_dnode *fn;
 355         struct jffs2_full_dirent *fd;
 356         uint32_t alloclen, phys_ofs;
 357         uint32_t writtenlen;
 358         int ret;
 359
 360         /* Try to reserve enough space for both node and dirent.
 361          * Just the node will do for now, though
 362          */
 363         ret = jffs2_reserve_space(c, sizeof(*ri), &phys_ofs, &alloclen, ALLOC_NORMAL);
 364         D1(printk(KERN_DEBUG "jffs2_do_create(): reserved 0x%x bytes\n", alloclen));
 365         if (ret) {
 366                 up(&f->sem);
 367                 return ret;
 368         }
 369
 370         ri->data_crc = 0;
 371         ri->node_crc = crc32(0, ri, sizeof(*ri)-8);
 372
 373         fn = jffs2_write_dnode(c, f, ri, NULL, 0, phys_ofs, &writtenlen);
 374
 375         D1(printk(KERN_DEBUG "jffs2_do_create created file with mode 0x%x\n", ri->mode));
 376
 377         if (IS_ERR(fn)) {
 378                 D1(printk(KERN_DEBUG "jffs2_write_dnode() failed\n"));
 379                 /* Eeek. Wave bye bye */
 380                 up(&f->sem);
 381                 jffs2_complete_reservation(c);
 382                 return PTR_ERR(fn);
 383         }
 384         /* No data here. Only a metadata node, which will be
 385            obsoleted by the first data write
 386         */
 387         f->metadata = fn;
 388
 389         /* Work out where to put the dirent node now. */
 390         writtenlen = PAD(writtenlen);
 391         phys_ofs += writtenlen;
 392         alloclen -= writtenlen;
 393         up(&f->sem);
 394
 395         if (alloclen < sizeof(*rd)+namelen) {
 396                 /* Not enough space left in this chunk. Get some more */
 397                 jffs2_complete_reservation(c);
 398                 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen, ALLOC_NORMAL);
 399
 400                 if (ret) {
 401                         /* Eep. */
 402                         D1(printk(KERN_DEBUG "jffs2_reserve_space() for dirent failed\n"));
 403                         return ret;
 404                 }
 405         }
 406
 407         rd = jffs2_alloc_raw_dirent();
 408         if (!rd) {
 409                 /* Argh. Now we treat it like a normal delete */
 410                 jffs2_complete_reservation(c);
 411                 return -ENOMEM;
 412         }
 413
 414         down(&dir_f->sem);
 415
 416         rd->magic = JFFS2_MAGIC_BITMASK;
 417         rd->nodetype = JFFS2_NODETYPE_DIRENT;
 418         rd->totlen = sizeof(*rd) + namelen;
 419         rd->hdr_crc = crc32(0, rd, sizeof(struct jffs2_unknown_node)-4);
 420
 421         rd->pino = dir_f->inocache->ino;
 422         rd->version = ++dir_f->highest_version;
 423         rd->ino = ri->ino;
 424         rd->mctime = ri->ctime;
 425         rd->nsize = namelen;
 426         rd->type = DT_REG;
 427         rd->node_crc = crc32(0, rd, sizeof(*rd)-8);
 428         rd->name_crc = crc32(0, name, namelen);
 429
 430         fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, phys_ofs, &writtenlen);
 431
 432         jffs2_free_raw_dirent(rd);
 433
 434         if (IS_ERR(fd)) {
 435                 /* dirent failed to write. Delete the inode normally
 436                    as if it were the final unlink() */
 437                 jffs2_complete_reservation(c);
 438                 up(&dir_f->sem);
 439                 return PTR_ERR(fd);
 440         }
 441
 442         /* Link the fd into the inode's list, obsoleting an old
 443            one if necessary. */
 444         jffs2_add_fd_to_list(c, fd, &dir_f->dents);
 445
 446         jffs2_complete_reservation(c);
 447         up(&dir_f->sem);
 448
 449         return 0;
 450 }
 451
 452
 453 int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f,
 454                     const char *name, int namelen, struct jffs2_inode_info *dead_f)
 455 {
 456         struct jffs2_raw_dirent *rd;
 457         struct jffs2_full_dirent *fd;
 458         uint32_t alloclen, phys_ofs;
 459         int ret;
 460
 461         rd = jffs2_alloc_raw_dirent();
 462         if (!rd)
 463                 return -ENOMEM;
 464
 465         ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen, ALLOC_DELETION);
 466         if (ret) {
 467                 jffs2_free_raw_dirent(rd);
 468                 return ret;
 469         }
 470
 471         down(&dir_f->sem);
 472
 473         /* Build a deletion node */
 474         rd->magic = JFFS2_MAGIC_BITMASK;
 475         rd->nodetype = JFFS2_NODETYPE_DIRENT;
 476         rd->totlen = sizeof(*rd) + namelen;
 477         rd->hdr_crc = crc32(0, rd, sizeof(struct jffs2_unknown_node)-4);
 478
 479         rd->pino = dir_f->inocache->ino;
 480         rd->version = ++dir_f->highest_version;
 481         rd->ino = 0;
 482         rd->mctime = get_seconds();
 483         rd->nsize = namelen;
 484         rd->type = DT_UNKNOWN;
 485         rd->node_crc = crc32(0, rd, sizeof(*rd)-8);
 486         rd->name_crc = crc32(0, name, namelen);
 487
 488         fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, phys_ofs, NULL);
 489
 490         jffs2_free_raw_dirent(rd);
 491
 492         if (IS_ERR(fd)) {
 493                 jffs2_complete_reservation(c);
 494                 up(&dir_f->sem);
 495                 return PTR_ERR(fd);
 496         }
 497
 498         /* File it. This will mark the old one obsolete. */
 499         jffs2_add_fd_to_list(c, fd, &dir_f->dents);
 500
 501         jffs2_complete_reservation(c);
 502         up(&dir_f->sem);
 503
 504         /* dead_f is NULL if this was a rename not a real unlink */
 505         /* Also catch the !f->inocache case, where there was a dirent
 506            pointing to an inode which didn't exist. */
 507         if (dead_f && dead_f->inocache) {
 508
 509                 down(&dead_f->sem);
 510
 511                 while (dead_f->dents) {
 512                         /* There can be only deleted ones */
 513                         fd = dead_f->dents;
 514
 515                         dead_f->dents = fd->next;
 516
 517                         if (fd->ino) {
 518                                 printk(KERN_WARNING "Deleting inode #%u with active dentry \"%s\"->ino #%u\n",
 519                                        dead_f->inocache->ino, fd->name, fd->ino);
 520                         } else {
 521                                 D1(printk(KERN_DEBUG "Removing deletion dirent for \"%s\" from dir ino #%u\n", fd->name, dead_f->inocache->ino));
 522                         }
 523                         jffs2_mark_node_obsolete(c, fd->raw);
 524                         jffs2_free_full_dirent(fd);
 525                 }
 526
 527                 dead_f->inocache->nlink--;
 528                 /* NB: Caller must set inode nlink if appropriate */
 529                 up(&dead_f->sem);
 530         }
 531
 532         return 0;
 533 }
 534
 535
 536 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)
 537 {
 538         struct jffs2_raw_dirent *rd;
 539         struct jffs2_full_dirent *fd;
 540         uint32_t alloclen, phys_ofs;
 541         int ret;
 542
 543         rd = jffs2_alloc_raw_dirent();
 544         if (!rd)
 545                 return -ENOMEM;
 546
 547         ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen, ALLOC_NORMAL);
 548         if (ret) {
 549                 jffs2_free_raw_dirent(rd);
 550                 return ret;
 551         }
 552
 553         down(&dir_f->sem);
 554
 555         /* Build a deletion node */
 556         rd->magic = JFFS2_MAGIC_BITMASK;
 557         rd->nodetype = JFFS2_NODETYPE_DIRENT;
 558         rd->totlen = sizeof(*rd) + namelen;
 559         rd->hdr_crc = crc32(0, rd, sizeof(struct jffs2_unknown_node)-4);
 560
 561         rd->pino = dir_f->inocache->ino;
 562         rd->version = ++dir_f->highest_version;
 563         rd->ino = ino;
 564         rd->mctime = get_seconds();
 565         rd->nsize = namelen;
 566
 567         rd->type = type;
 568
 569         rd->node_crc = crc32(0, rd, sizeof(*rd)-8);
 570         rd->name_crc = crc32(0, name, namelen);
 571
 572         fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, phys_ofs, NULL);
 573
 574         jffs2_free_raw_dirent(rd);
 575
 576         if (IS_ERR(fd)) {
 577                 jffs2_complete_reservation(c);
 578                 up(&dir_f->sem);
 579                 return PTR_ERR(fd);
 580         }
 581
 582         /* File it. This will mark the old one obsolete. */
 583         jffs2_add_fd_to_list(c, fd, &dir_f->dents);
 584
 585         jffs2_complete_reservation(c);
 586         up(&dir_f->sem);
 587
 588         return 0;
 589 }