2 * JFFS2 -- Journalling Flash File System, Version 2.
4 * Copyright (C) 2001-2003 Red Hat, Inc.
6 * Created by David Woodhouse <dwmw2@infradead.org>
8 * For licensing information, see the file 'LICENCE' in this directory.
10 * $Id: write.c,v 1.95 2005/08/17 13:46:23 dedekind Exp $
14 #include <linux/kernel.h>
16 #include <linux/crc32.h>
17 #include <linux/slab.h>
18 #include <linux/pagemap.h>
19 #include <linux/mtd/mtd.h>
24 int jffs2_do_new_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, uint32_t mode, struct jffs2_raw_inode *ri)
26 struct jffs2_inode_cache *ic;
28 ic = jffs2_alloc_inode_cache();
33 memset(ic, 0, sizeof(*ic));
36 f->inocache->nlink = 1;
37 f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache;
38 f->inocache->state = INO_STATE_PRESENT;
41 jffs2_add_ino_cache(c, f->inocache);
42 D1(printk(KERN_DEBUG "jffs2_do_new_inode(): Assigned ino# %d\n", f->inocache->ino));
43 ri->ino = cpu_to_je32(f->inocache->ino);
45 ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
46 ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
47 ri->totlen = cpu_to_je32(PAD(sizeof(*ri)));
48 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
49 ri->mode = cpu_to_jemode(mode);
51 f->highest_version = 1;
52 ri->version = cpu_to_je32(f->highest_version);
57 /* jffs2_write_dnode - given a raw_inode, allocate a full_dnode for it,
58 write it to the flash, link it into the existing inode/fragment list */
60 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, int alloc_mode)
63 struct jffs2_raw_node_ref *raw;
64 struct jffs2_full_dnode *fn;
69 unsigned long cnt = 2;
71 D1(if(je32_to_cpu(ri->hdr_crc) != crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)) {
72 printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dnode()\n");
76 vecs[0].iov_base = ri;
77 vecs[0].iov_len = sizeof(*ri);
78 vecs[1].iov_base = (unsigned char *)data;
79 vecs[1].iov_len = datalen;
81 jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len);
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);
86 raw = jffs2_alloc_raw_node_ref();
88 return ERR_PTR(-ENOMEM);
90 fn = jffs2_alloc_full_dnode();
92 jffs2_free_raw_node_ref(raw);
93 return ERR_PTR(-ENOMEM);
96 fn->ofs = je32_to_cpu(ri->offset);
97 fn->size = je32_to_cpu(ri->dsize);
100 /* check number of valid vecs */
101 if (!datalen || !data)
106 raw->flash_offset = flash_ofs;
107 raw->__totlen = PAD(sizeof(*ri)+datalen);
108 raw->next_phys = NULL;
110 if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(ri->version) < f->highest_version)) {
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));
119 ret = jffs2_flash_writev(c, vecs, cnt, flash_ofs, &retlen,
120 (alloc_mode==ALLOC_GC)?0:f->inocache->ino);
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);
126 /* Mark the space as dirtied */
128 /* Doesn't belong to any inode */
129 raw->next_in_ino = NULL;
131 /* Don't change raw->size to match retlen. We may have
132 written the node header already, and only the data will
133 seem corrupted, in which case the scan would skip over
134 any node we write before the original intended end of
136 raw->flash_offset |= REF_OBSOLETE;
137 jffs2_add_physical_node_ref(c, raw);
138 jffs2_mark_node_obsolete(c, raw);
140 printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", raw->flash_offset);
141 jffs2_free_raw_node_ref(raw);
143 if (!retried && alloc_mode != ALLOC_NORETRY && (raw = jffs2_alloc_raw_node_ref())) {
144 /* Try to reallocate space and retry */
146 struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
150 D1(printk(KERN_DEBUG "Retrying failed write.\n"));
152 jffs2_dbg_acct_sanity_check(c,jeb);
153 jffs2_dbg_acct_paranoia_check(c, jeb);
155 if (alloc_mode == ALLOC_GC) {
156 ret = jffs2_reserve_space_gc(c, sizeof(*ri) + datalen, &flash_ofs, &dummy);
160 jffs2_complete_reservation(c);
162 ret = jffs2_reserve_space(c, sizeof(*ri) + datalen, &flash_ofs, &dummy, alloc_mode);
167 D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs));
169 jffs2_dbg_acct_sanity_check(c,jeb);
170 jffs2_dbg_acct_paranoia_check(c, jeb);
174 D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret));
175 jffs2_free_raw_node_ref(raw);
177 /* Release the full_dnode which is now useless, and return */
178 jffs2_free_full_dnode(fn);
179 return ERR_PTR(ret?ret:-EIO);
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.
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;
191 raw->flash_offset |= REF_NORMAL;
193 jffs2_add_physical_node_ref(c, raw);
195 /* Link into per-inode list */
196 spin_lock(&c->erase_completion_lock);
197 raw->next_in_ino = f->inocache->nodes;
198 f->inocache->nodes = raw;
199 spin_unlock(&c->erase_completion_lock);
201 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",
202 flash_ofs, ref_flags(raw), je32_to_cpu(ri->dsize),
203 je32_to_cpu(ri->csize), je32_to_cpu(ri->node_crc),
204 je32_to_cpu(ri->data_crc), je32_to_cpu(ri->totlen)));
207 jffs2_dbg_acct_sanity_check(c,NULL);
213 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, int alloc_mode)
215 struct jffs2_raw_node_ref *raw;
216 struct jffs2_full_dirent *fd;
222 D1(printk(KERN_DEBUG "jffs2_write_dirent(ino #%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)));
226 D1(if(je32_to_cpu(rd->hdr_crc) != crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)) {
227 printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dirent()\n");
232 vecs[0].iov_base = rd;
233 vecs[0].iov_len = sizeof(*rd);
234 vecs[1].iov_base = (unsigned char *)name;
235 vecs[1].iov_len = namelen;
237 jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len);
239 raw = jffs2_alloc_raw_node_ref();
242 return ERR_PTR(-ENOMEM);
244 fd = jffs2_alloc_full_dirent(namelen+1);
246 jffs2_free_raw_node_ref(raw);
247 return ERR_PTR(-ENOMEM);
250 fd->version = je32_to_cpu(rd->version);
251 fd->ino = je32_to_cpu(rd->ino);
252 fd->nhash = full_name_hash(name, strlen(name));
254 memcpy(fd->name, name, namelen);
260 raw->flash_offset = flash_ofs;
261 raw->__totlen = PAD(sizeof(*rd)+namelen);
262 raw->next_phys = NULL;
264 if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(rd->version) < f->highest_version)) {
266 D1(printk(KERN_DEBUG "jffs2_write_dirent : dirent_version %d, "
267 "highest version %d -> updating dirent\n",
268 je32_to_cpu(rd->version), f->highest_version));
269 rd->version = cpu_to_je32(++f->highest_version);
270 fd->version = je32_to_cpu(rd->version);
271 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
274 ret = jffs2_flash_writev(c, vecs, 2, flash_ofs, &retlen,
275 (alloc_mode==ALLOC_GC)?0:je32_to_cpu(rd->pino));
276 if (ret || (retlen != sizeof(*rd) + namelen)) {
277 printk(KERN_NOTICE "Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
278 sizeof(*rd)+namelen, flash_ofs, ret, retlen);
279 /* Mark the space as dirtied */
281 raw->next_in_ino = NULL;
282 raw->flash_offset |= REF_OBSOLETE;
283 jffs2_add_physical_node_ref(c, raw);
284 jffs2_mark_node_obsolete(c, raw);
286 printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", raw->flash_offset);
287 jffs2_free_raw_node_ref(raw);
289 if (!retried && (raw = jffs2_alloc_raw_node_ref())) {
290 /* Try to reallocate space and retry */
292 struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
296 D1(printk(KERN_DEBUG "Retrying failed write.\n"));
298 jffs2_dbg_acct_sanity_check(c,jeb);
299 jffs2_dbg_acct_paranoia_check(c, jeb);
301 if (alloc_mode == ALLOC_GC) {
302 ret = jffs2_reserve_space_gc(c, sizeof(*rd) + namelen, &flash_ofs, &dummy);
306 jffs2_complete_reservation(c);
308 ret = jffs2_reserve_space(c, sizeof(*rd) + namelen, &flash_ofs, &dummy, alloc_mode);
313 D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs));
314 jffs2_dbg_acct_sanity_check(c,jeb);
315 jffs2_dbg_acct_paranoia_check(c, jeb);
318 D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret));
319 jffs2_free_raw_node_ref(raw);
321 /* Release the full_dnode which is now useless, and return */
322 jffs2_free_full_dirent(fd);
323 return ERR_PTR(ret?ret:-EIO);
325 /* Mark the space used */
326 raw->flash_offset |= REF_PRISTINE;
327 jffs2_add_physical_node_ref(c, raw);
329 spin_lock(&c->erase_completion_lock);
330 raw->next_in_ino = f->inocache->nodes;
331 f->inocache->nodes = raw;
332 spin_unlock(&c->erase_completion_lock);
335 jffs2_dbg_acct_sanity_check(c,NULL);
341 /* The OS-specific code fills in the metadata in the jffs2_raw_inode for us, so that
342 we don't have to go digging in struct inode or its equivalent. It should set:
343 mode, uid, gid, (starting)isize, atime, ctime, mtime */
344 int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
345 struct jffs2_raw_inode *ri, unsigned char *buf,
346 uint32_t offset, uint32_t writelen, uint32_t *retlen)
349 uint32_t writtenlen = 0;
351 D1(printk(KERN_DEBUG "jffs2_write_inode_range(): Ino #%u, ofs 0x%x, len 0x%x\n",
352 f->inocache->ino, offset, writelen));
355 struct jffs2_full_dnode *fn;
356 unsigned char *comprbuf = NULL;
357 uint16_t comprtype = JFFS2_COMPR_NONE;
358 uint32_t phys_ofs, alloclen;
359 uint32_t datalen, cdatalen;
363 D2(printk(KERN_DEBUG "jffs2_commit_write() loop: 0x%x to write to 0x%x\n", writelen, offset));
365 ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN, &phys_ofs, &alloclen, ALLOC_NORMAL);
367 D1(printk(KERN_DEBUG "jffs2_reserve_space returned %d\n", ret));
371 datalen = min_t(uint32_t, writelen, PAGE_CACHE_SIZE - (offset & (PAGE_CACHE_SIZE-1)));
372 cdatalen = min_t(uint32_t, alloclen - sizeof(*ri), datalen);
374 comprtype = jffs2_compress(c, f, buf, &comprbuf, &datalen, &cdatalen);
376 ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
377 ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
378 ri->totlen = cpu_to_je32(sizeof(*ri) + cdatalen);
379 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
381 ri->ino = cpu_to_je32(f->inocache->ino);
382 ri->version = cpu_to_je32(++f->highest_version);
383 ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen));
384 ri->offset = cpu_to_je32(offset);
385 ri->csize = cpu_to_je32(cdatalen);
386 ri->dsize = cpu_to_je32(datalen);
387 ri->compr = comprtype & 0xff;
388 ri->usercompr = (comprtype >> 8 ) & 0xff;
389 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
390 ri->data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
392 fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, phys_ofs, ALLOC_NORETRY);
394 jffs2_free_comprbuf(comprbuf, buf);
399 jffs2_complete_reservation(c);
401 /* Write error to be retried */
403 D1(printk(KERN_DEBUG "Retrying node write in jffs2_write_inode_range()\n"));
408 ret = jffs2_add_full_dnode_to_inode(c, f, fn);
410 jffs2_mark_node_obsolete(c, f->metadata->raw);
411 jffs2_free_full_dnode(f->metadata);
416 D1(printk(KERN_DEBUG "Eep. add_full_dnode_to_inode() failed in commit_write, returned %d\n", ret));
417 jffs2_mark_node_obsolete(c, fn->raw);
418 jffs2_free_full_dnode(fn);
421 jffs2_complete_reservation(c);
425 jffs2_complete_reservation(c);
427 printk(KERN_WARNING "Eep. We didn't actually write any data in jffs2_write_inode_range()\n");
431 D1(printk(KERN_DEBUG "increasing writtenlen by %d\n", datalen));
432 writtenlen += datalen;
437 *retlen = writtenlen;
441 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)
443 struct jffs2_raw_dirent *rd;
444 struct jffs2_full_dnode *fn;
445 struct jffs2_full_dirent *fd;
446 uint32_t alloclen, phys_ofs;
449 /* Try to reserve enough space for both node and dirent.
450 * Just the node will do for now, though
452 ret = jffs2_reserve_space(c, sizeof(*ri), &phys_ofs, &alloclen, ALLOC_NORMAL);
453 D1(printk(KERN_DEBUG "jffs2_do_create(): reserved 0x%x bytes\n", alloclen));
459 ri->data_crc = cpu_to_je32(0);
460 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
462 fn = jffs2_write_dnode(c, f, ri, NULL, 0, phys_ofs, ALLOC_NORMAL);
464 D1(printk(KERN_DEBUG "jffs2_do_create created file with mode 0x%x\n",
465 jemode_to_cpu(ri->mode)));
468 D1(printk(KERN_DEBUG "jffs2_write_dnode() failed\n"));
469 /* Eeek. Wave bye bye */
471 jffs2_complete_reservation(c);
474 /* No data here. Only a metadata node, which will be
475 obsoleted by the first data write
480 jffs2_complete_reservation(c);
481 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen, ALLOC_NORMAL);
485 D1(printk(KERN_DEBUG "jffs2_reserve_space() for dirent failed\n"));
489 rd = jffs2_alloc_raw_dirent();
491 /* Argh. Now we treat it like a normal delete */
492 jffs2_complete_reservation(c);
498 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
499 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
500 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
501 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
503 rd->pino = cpu_to_je32(dir_f->inocache->ino);
504 rd->version = cpu_to_je32(++dir_f->highest_version);
506 rd->mctime = ri->ctime;
509 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
510 rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
512 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, phys_ofs, ALLOC_NORMAL);
514 jffs2_free_raw_dirent(rd);
517 /* dirent failed to write. Delete the inode normally
518 as if it were the final unlink() */
519 jffs2_complete_reservation(c);
524 /* Link the fd into the inode's list, obsoleting an old
526 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
528 jffs2_complete_reservation(c);
535 int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f,
536 const char *name, int namelen, struct jffs2_inode_info *dead_f,
539 struct jffs2_raw_dirent *rd;
540 struct jffs2_full_dirent *fd;
541 uint32_t alloclen, phys_ofs;
544 if (1 /* alternative branch needs testing */ ||
545 !jffs2_can_mark_obsolete(c)) {
546 /* We can't mark stuff obsolete on the medium. We need to write a deletion dirent */
548 rd = jffs2_alloc_raw_dirent();
552 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen, ALLOC_DELETION);
554 jffs2_free_raw_dirent(rd);
560 /* Build a deletion node */
561 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
562 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
563 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
564 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
566 rd->pino = cpu_to_je32(dir_f->inocache->ino);
567 rd->version = cpu_to_je32(++dir_f->highest_version);
568 rd->ino = cpu_to_je32(0);
569 rd->mctime = cpu_to_je32(time);
571 rd->type = DT_UNKNOWN;
572 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
573 rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
575 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, phys_ofs, ALLOC_DELETION);
577 jffs2_free_raw_dirent(rd);
580 jffs2_complete_reservation(c);
585 /* File it. This will mark the old one obsolete. */
586 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
589 struct jffs2_full_dirent **prev = &dir_f->dents;
590 uint32_t nhash = full_name_hash(name, namelen);
594 while ((*prev) && (*prev)->nhash <= nhash) {
595 if ((*prev)->nhash == nhash &&
596 !memcmp((*prev)->name, name, namelen) &&
597 !(*prev)->name[namelen]) {
598 struct jffs2_full_dirent *this = *prev;
600 D1(printk(KERN_DEBUG "Marking old dirent node (ino #%u) @%08x obsolete\n",
601 this->ino, ref_offset(this->raw)));
604 jffs2_mark_node_obsolete(c, (this->raw));
605 jffs2_free_full_dirent(this);
608 prev = &((*prev)->next);
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) {
620 if (S_ISDIR(OFNI_EDONI_2SFFJ(dead_f)->i_mode)) {
621 while (dead_f->dents) {
622 /* There can be only deleted ones */
625 dead_f->dents = fd->next;
628 printk(KERN_WARNING "Deleting inode #%u with active dentry \"%s\"->ino #%u\n",
629 dead_f->inocache->ino, fd->name, fd->ino);
631 D1(printk(KERN_DEBUG "Removing deletion dirent for \"%s\" from dir ino #%u\n",
632 fd->name, dead_f->inocache->ino));
634 jffs2_mark_node_obsolete(c, fd->raw);
635 jffs2_free_full_dirent(fd);
639 dead_f->inocache->nlink--;
640 /* NB: Caller must set inode nlink if appropriate */
644 jffs2_complete_reservation(c);
650 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 struct jffs2_raw_dirent *rd;
653 struct jffs2_full_dirent *fd;
654 uint32_t alloclen, phys_ofs;
657 rd = jffs2_alloc_raw_dirent();
661 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen, ALLOC_NORMAL);
663 jffs2_free_raw_dirent(rd);
669 /* Build a deletion node */
670 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
671 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
672 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
673 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
675 rd->pino = cpu_to_je32(dir_f->inocache->ino);
676 rd->version = cpu_to_je32(++dir_f->highest_version);
677 rd->ino = cpu_to_je32(ino);
678 rd->mctime = cpu_to_je32(time);
683 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
684 rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
686 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, phys_ofs, ALLOC_NORMAL);
688 jffs2_free_raw_dirent(rd);
691 jffs2_complete_reservation(c);
696 /* File it. This will mark the old one obsolete. */
697 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
699 jffs2_complete_reservation(c);