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.94 2005/07/20 15:50:51 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)
538 struct jffs2_raw_dirent *rd;
539 struct jffs2_full_dirent *fd;
540 uint32_t alloclen, phys_ofs;
543 if (1 /* alternative branch needs testing */ ||
544 !jffs2_can_mark_obsolete(c)) {
545 /* We can't mark stuff obsolete on the medium. We need to write a deletion dirent */
547 rd = jffs2_alloc_raw_dirent();
551 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen, ALLOC_DELETION);
553 jffs2_free_raw_dirent(rd);
559 /* Build a deletion node */
560 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
561 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
562 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
563 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
565 rd->pino = cpu_to_je32(dir_f->inocache->ino);
566 rd->version = cpu_to_je32(++dir_f->highest_version);
567 rd->ino = cpu_to_je32(0);
568 rd->mctime = cpu_to_je32(get_seconds());
570 rd->type = DT_UNKNOWN;
571 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
572 rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
574 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, phys_ofs, ALLOC_DELETION);
576 jffs2_free_raw_dirent(rd);
579 jffs2_complete_reservation(c);
584 /* File it. This will mark the old one obsolete. */
585 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
588 struct jffs2_full_dirent **prev = &dir_f->dents;
589 uint32_t nhash = full_name_hash(name, namelen);
593 while ((*prev) && (*prev)->nhash <= nhash) {
594 if ((*prev)->nhash == nhash &&
595 !memcmp((*prev)->name, name, namelen) &&
596 !(*prev)->name[namelen]) {
597 struct jffs2_full_dirent *this = *prev;
599 D1(printk(KERN_DEBUG "Marking old dirent node (ino #%u) @%08x obsolete\n",
600 this->ino, ref_offset(this->raw)));
603 jffs2_mark_node_obsolete(c, (this->raw));
604 jffs2_free_full_dirent(this);
607 prev = &((*prev)->next);
612 /* dead_f is NULL if this was a rename not a real unlink */
613 /* Also catch the !f->inocache case, where there was a dirent
614 pointing to an inode which didn't exist. */
615 if (dead_f && dead_f->inocache) {
619 if (S_ISDIR(OFNI_EDONI_2SFFJ(dead_f)->i_mode)) {
620 while (dead_f->dents) {
621 /* There can be only deleted ones */
624 dead_f->dents = fd->next;
627 printk(KERN_WARNING "Deleting inode #%u with active dentry \"%s\"->ino #%u\n",
628 dead_f->inocache->ino, fd->name, fd->ino);
630 D1(printk(KERN_DEBUG "Removing deletion dirent for \"%s\" from dir ino #%u\n",
631 fd->name, dead_f->inocache->ino));
633 jffs2_mark_node_obsolete(c, fd->raw);
634 jffs2_free_full_dirent(fd);
638 dead_f->inocache->nlink--;
639 /* NB: Caller must set inode nlink if appropriate */
643 jffs2_complete_reservation(c);
649 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)
651 struct jffs2_raw_dirent *rd;
652 struct jffs2_full_dirent *fd;
653 uint32_t alloclen, phys_ofs;
656 rd = jffs2_alloc_raw_dirent();
660 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen, ALLOC_NORMAL);
662 jffs2_free_raw_dirent(rd);
668 /* Build a deletion node */
669 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
670 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
671 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
672 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
674 rd->pino = cpu_to_je32(dir_f->inocache->ino);
675 rd->version = cpu_to_je32(++dir_f->highest_version);
676 rd->ino = cpu_to_je32(ino);
677 rd->mctime = cpu_to_je32(get_seconds());
682 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
683 rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
685 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, phys_ofs, ALLOC_NORMAL);
687 jffs2_free_raw_dirent(rd);
690 jffs2_complete_reservation(c);
695 /* File it. This will mark the old one obsolete. */
696 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
698 jffs2_complete_reservation(c);