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.97 2005/11/07 11:14:42 gleixner 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;
40 jffs2_add_ino_cache(c, f->inocache);
41 D1(printk(KERN_DEBUG "jffs2_do_new_inode(): Assigned ino# %d\n", f->inocache->ino));
42 ri->ino = cpu_to_je32(f->inocache->ino);
44 ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
45 ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
46 ri->totlen = cpu_to_je32(PAD(sizeof(*ri)));
47 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
48 ri->mode = cpu_to_jemode(mode);
50 f->highest_version = 1;
51 ri->version = cpu_to_je32(f->highest_version);
56 /* jffs2_write_dnode - given a raw_inode, allocate a full_dnode for it,
57 write it to the flash, link it into the existing inode/fragment list */
59 struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
60 struct jffs2_raw_inode *ri, const unsigned char *data,
61 uint32_t datalen, int alloc_mode)
64 struct jffs2_raw_node_ref *raw;
65 struct jffs2_full_dnode *fn;
71 unsigned long cnt = 2;
73 D1(if(je32_to_cpu(ri->hdr_crc) != crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)) {
74 printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dnode()\n");
78 vecs[0].iov_base = ri;
79 vecs[0].iov_len = sizeof(*ri);
80 vecs[1].iov_base = (unsigned char *)data;
81 vecs[1].iov_len = datalen;
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 = write_ofs(c);
108 jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len);
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 /* Don't change raw->size to match retlen. We may have
129 written the node header already, and only the data will
130 seem corrupted, in which case the scan would skip over
131 any node we write before the original intended end of
133 raw->flash_offset |= REF_OBSOLETE;
134 jffs2_add_physical_node_ref(c, raw, PAD(sizeof(*ri)+datalen), NULL);
135 jffs2_mark_node_obsolete(c, raw);
137 printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", raw->flash_offset);
138 jffs2_free_raw_node_ref(raw);
140 if (!retried && alloc_mode != ALLOC_NORETRY && (raw = jffs2_alloc_raw_node_ref())) {
141 /* Try to reallocate space and retry */
143 struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
147 D1(printk(KERN_DEBUG "Retrying failed write.\n"));
149 jffs2_dbg_acct_sanity_check(c,jeb);
150 jffs2_dbg_acct_paranoia_check(c, jeb);
152 if (alloc_mode == ALLOC_GC) {
153 ret = jffs2_reserve_space_gc(c, sizeof(*ri) + datalen, &dummy,
154 JFFS2_SUMMARY_INODE_SIZE);
158 jffs2_complete_reservation(c);
160 ret = jffs2_reserve_space(c, sizeof(*ri) + datalen, &dummy,
161 alloc_mode, JFFS2_SUMMARY_INODE_SIZE);
166 flash_ofs = write_ofs(c);
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, PAD(sizeof(*ri)+datalen), f->inocache);
195 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",
196 flash_ofs, ref_flags(raw), je32_to_cpu(ri->dsize),
197 je32_to_cpu(ri->csize), je32_to_cpu(ri->node_crc),
198 je32_to_cpu(ri->data_crc), je32_to_cpu(ri->totlen)));
201 jffs2_dbg_acct_sanity_check(c,NULL);
207 struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
208 struct jffs2_raw_dirent *rd, const unsigned char *name,
209 uint32_t namelen, int alloc_mode)
211 struct jffs2_raw_node_ref *raw;
212 struct jffs2_full_dirent *fd;
215 uint32_t flash_ofs = write_ofs(c);
219 D1(printk(KERN_DEBUG "jffs2_write_dirent(ino #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x)\n",
220 je32_to_cpu(rd->pino), name, name, je32_to_cpu(rd->ino),
221 je32_to_cpu(rd->name_crc)));
223 D1(if(je32_to_cpu(rd->hdr_crc) != crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)) {
224 printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dirent()\n");
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;
234 jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len);
236 raw = jffs2_alloc_raw_node_ref();
239 return ERR_PTR(-ENOMEM);
241 fd = jffs2_alloc_full_dirent(namelen+1);
243 jffs2_free_raw_node_ref(raw);
244 return ERR_PTR(-ENOMEM);
247 fd->version = je32_to_cpu(rd->version);
248 fd->ino = je32_to_cpu(rd->ino);
249 fd->nhash = full_name_hash(name, strlen(name));
251 memcpy(fd->name, name, namelen);
257 raw->flash_offset = flash_ofs;
259 if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(rd->version) < f->highest_version)) {
261 D1(printk(KERN_DEBUG "jffs2_write_dirent : dirent_version %d, "
262 "highest version %d -> updating dirent\n",
263 je32_to_cpu(rd->version), f->highest_version));
264 rd->version = cpu_to_je32(++f->highest_version);
265 fd->version = je32_to_cpu(rd->version);
266 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
269 ret = jffs2_flash_writev(c, vecs, 2, flash_ofs, &retlen,
270 (alloc_mode==ALLOC_GC)?0:je32_to_cpu(rd->pino));
271 if (ret || (retlen != sizeof(*rd) + namelen)) {
272 printk(KERN_NOTICE "Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
273 sizeof(*rd)+namelen, flash_ofs, ret, retlen);
274 /* Mark the space as dirtied */
276 raw->flash_offset |= REF_OBSOLETE;
277 jffs2_add_physical_node_ref(c, raw, PAD(sizeof(*rd)+namelen), NULL);
278 jffs2_mark_node_obsolete(c, raw);
280 printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", raw->flash_offset);
281 jffs2_free_raw_node_ref(raw);
283 if (!retried && (raw = jffs2_alloc_raw_node_ref())) {
284 /* Try to reallocate space and retry */
286 struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
290 D1(printk(KERN_DEBUG "Retrying failed write.\n"));
292 jffs2_dbg_acct_sanity_check(c,jeb);
293 jffs2_dbg_acct_paranoia_check(c, jeb);
295 if (alloc_mode == ALLOC_GC) {
296 ret = jffs2_reserve_space_gc(c, sizeof(*rd) + namelen, &dummy,
297 JFFS2_SUMMARY_DIRENT_SIZE(namelen));
301 jffs2_complete_reservation(c);
303 ret = jffs2_reserve_space(c, sizeof(*rd) + namelen, &dummy,
304 alloc_mode, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
309 flash_ofs = write_ofs(c);
310 D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs));
311 jffs2_dbg_acct_sanity_check(c,jeb);
312 jffs2_dbg_acct_paranoia_check(c, jeb);
315 D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret));
316 jffs2_free_raw_node_ref(raw);
318 /* Release the full_dnode which is now useless, and return */
319 jffs2_free_full_dirent(fd);
320 return ERR_PTR(ret?ret:-EIO);
322 /* Mark the space used */
323 raw->flash_offset |= REF_PRISTINE;
324 jffs2_add_physical_node_ref(c, raw, PAD(sizeof(*rd)+namelen), f->inocache);
327 jffs2_dbg_acct_sanity_check(c,NULL);
333 /* The OS-specific code fills in the metadata in the jffs2_raw_inode for us, so that
334 we don't have to go digging in struct inode or its equivalent. It should set:
335 mode, uid, gid, (starting)isize, atime, ctime, mtime */
336 int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
337 struct jffs2_raw_inode *ri, unsigned char *buf,
338 uint32_t offset, uint32_t writelen, uint32_t *retlen)
341 uint32_t writtenlen = 0;
343 D1(printk(KERN_DEBUG "jffs2_write_inode_range(): Ino #%u, ofs 0x%x, len 0x%x\n",
344 f->inocache->ino, offset, writelen));
347 struct jffs2_full_dnode *fn;
348 unsigned char *comprbuf = NULL;
349 uint16_t comprtype = JFFS2_COMPR_NONE;
351 uint32_t datalen, cdatalen;
355 D2(printk(KERN_DEBUG "jffs2_commit_write() loop: 0x%x to write to 0x%x\n", writelen, offset));
357 ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN,
358 &alloclen, ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
360 D1(printk(KERN_DEBUG "jffs2_reserve_space returned %d\n", ret));
364 datalen = min_t(uint32_t, writelen, PAGE_CACHE_SIZE - (offset & (PAGE_CACHE_SIZE-1)));
365 cdatalen = min_t(uint32_t, alloclen - sizeof(*ri), datalen);
367 comprtype = jffs2_compress(c, f, buf, &comprbuf, &datalen, &cdatalen);
369 ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
370 ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
371 ri->totlen = cpu_to_je32(sizeof(*ri) + cdatalen);
372 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
374 ri->ino = cpu_to_je32(f->inocache->ino);
375 ri->version = cpu_to_je32(++f->highest_version);
376 ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen));
377 ri->offset = cpu_to_je32(offset);
378 ri->csize = cpu_to_je32(cdatalen);
379 ri->dsize = cpu_to_je32(datalen);
380 ri->compr = comprtype & 0xff;
381 ri->usercompr = (comprtype >> 8 ) & 0xff;
382 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
383 ri->data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
385 fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, ALLOC_NORETRY);
387 jffs2_free_comprbuf(comprbuf, buf);
392 jffs2_complete_reservation(c);
394 /* Write error to be retried */
396 D1(printk(KERN_DEBUG "Retrying node write in jffs2_write_inode_range()\n"));
401 ret = jffs2_add_full_dnode_to_inode(c, f, fn);
403 jffs2_mark_node_obsolete(c, f->metadata->raw);
404 jffs2_free_full_dnode(f->metadata);
409 D1(printk(KERN_DEBUG "Eep. add_full_dnode_to_inode() failed in commit_write, returned %d\n", ret));
410 jffs2_mark_node_obsolete(c, fn->raw);
411 jffs2_free_full_dnode(fn);
414 jffs2_complete_reservation(c);
418 jffs2_complete_reservation(c);
420 printk(KERN_WARNING "Eep. We didn't actually write any data in jffs2_write_inode_range()\n");
424 D1(printk(KERN_DEBUG "increasing writtenlen by %d\n", datalen));
425 writtenlen += datalen;
430 *retlen = writtenlen;
434 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)
436 struct jffs2_raw_dirent *rd;
437 struct jffs2_full_dnode *fn;
438 struct jffs2_full_dirent *fd;
442 /* Try to reserve enough space for both node and dirent.
443 * Just the node will do for now, though
445 ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL,
446 JFFS2_SUMMARY_INODE_SIZE);
447 D1(printk(KERN_DEBUG "jffs2_do_create(): reserved 0x%x bytes\n", alloclen));
453 ri->data_crc = cpu_to_je32(0);
454 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
456 fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL);
458 D1(printk(KERN_DEBUG "jffs2_do_create created file with mode 0x%x\n",
459 jemode_to_cpu(ri->mode)));
462 D1(printk(KERN_DEBUG "jffs2_write_dnode() failed\n"));
463 /* Eeek. Wave bye bye */
465 jffs2_complete_reservation(c);
468 /* No data here. Only a metadata node, which will be
469 obsoleted by the first data write
474 jffs2_complete_reservation(c);
475 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
476 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
480 D1(printk(KERN_DEBUG "jffs2_reserve_space() for dirent failed\n"));
484 rd = jffs2_alloc_raw_dirent();
486 /* Argh. Now we treat it like a normal delete */
487 jffs2_complete_reservation(c);
493 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
494 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
495 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
496 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
498 rd->pino = cpu_to_je32(dir_f->inocache->ino);
499 rd->version = cpu_to_je32(++dir_f->highest_version);
501 rd->mctime = ri->ctime;
504 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
505 rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
507 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL);
509 jffs2_free_raw_dirent(rd);
512 /* dirent failed to write. Delete the inode normally
513 as if it were the final unlink() */
514 jffs2_complete_reservation(c);
519 /* Link the fd into the inode's list, obsoleting an old
521 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
523 jffs2_complete_reservation(c);
530 int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f,
531 const char *name, int namelen, struct jffs2_inode_info *dead_f,
534 struct jffs2_raw_dirent *rd;
535 struct jffs2_full_dirent *fd;
539 if (1 /* alternative branch needs testing */ ||
540 !jffs2_can_mark_obsolete(c)) {
541 /* We can't mark stuff obsolete on the medium. We need to write a deletion dirent */
543 rd = jffs2_alloc_raw_dirent();
547 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
548 ALLOC_DELETION, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
550 jffs2_free_raw_dirent(rd);
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));
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);
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));
571 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_DELETION);
573 jffs2_free_raw_dirent(rd);
576 jffs2_complete_reservation(c);
581 /* File it. This will mark the old one obsolete. */
582 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
585 struct jffs2_full_dirent **prev = &dir_f->dents;
586 uint32_t nhash = full_name_hash(name, namelen);
590 while ((*prev) && (*prev)->nhash <= nhash) {
591 if ((*prev)->nhash == nhash &&
592 !memcmp((*prev)->name, name, namelen) &&
593 !(*prev)->name[namelen]) {
594 struct jffs2_full_dirent *this = *prev;
596 D1(printk(KERN_DEBUG "Marking old dirent node (ino #%u) @%08x obsolete\n",
597 this->ino, ref_offset(this->raw)));
600 jffs2_mark_node_obsolete(c, (this->raw));
601 jffs2_free_full_dirent(this);
604 prev = &((*prev)->next);
609 /* dead_f is NULL if this was a rename not a real unlink */
610 /* Also catch the !f->inocache case, where there was a dirent
611 pointing to an inode which didn't exist. */
612 if (dead_f && dead_f->inocache) {
616 if (S_ISDIR(OFNI_EDONI_2SFFJ(dead_f)->i_mode)) {
617 while (dead_f->dents) {
618 /* There can be only deleted ones */
621 dead_f->dents = fd->next;
624 printk(KERN_WARNING "Deleting inode #%u with active dentry \"%s\"->ino #%u\n",
625 dead_f->inocache->ino, fd->name, fd->ino);
627 D1(printk(KERN_DEBUG "Removing deletion dirent for \"%s\" from dir ino #%u\n",
628 fd->name, dead_f->inocache->ino));
630 jffs2_mark_node_obsolete(c, fd->raw);
631 jffs2_free_full_dirent(fd);
635 dead_f->inocache->nlink--;
636 /* NB: Caller must set inode nlink if appropriate */
640 jffs2_complete_reservation(c);
646 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)
648 struct jffs2_raw_dirent *rd;
649 struct jffs2_full_dirent *fd;
653 rd = jffs2_alloc_raw_dirent();
657 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
658 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
660 jffs2_free_raw_dirent(rd);
666 /* Build a deletion node */
667 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
668 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
669 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
670 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
672 rd->pino = cpu_to_je32(dir_f->inocache->ino);
673 rd->version = cpu_to_je32(++dir_f->highest_version);
674 rd->ino = cpu_to_je32(ino);
675 rd->mctime = cpu_to_je32(time);
680 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
681 rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
683 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL);
685 jffs2_free_raw_dirent(rd);
688 jffs2_complete_reservation(c);
693 /* File it. This will mark the old one obsolete. */
694 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
696 jffs2_complete_reservation(c);