2 * JFFS2 -- Journalling Flash File System, Version 2.
4 * Copyright © 2001-2007 Red Hat, Inc.
6 * Created by David Woodhouse <dwmw2@infradead.org>
8 * For licensing information, see the file 'LICENCE' in this directory.
12 #include <linux/kernel.h>
14 #include <linux/crc32.h>
15 #include <linux/slab.h>
16 #include <linux/pagemap.h>
17 #include <linux/mtd/mtd.h>
22 int jffs2_do_new_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, uint32_t mode, struct jffs2_raw_inode *ri)
24 struct jffs2_inode_cache *ic;
26 ic = jffs2_alloc_inode_cache();
31 memset(ic, 0, sizeof(*ic));
34 f->inocache->nlink = 1;
35 f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache;
36 f->inocache->state = INO_STATE_PRESENT;
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);
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);
48 f->highest_version = 1;
49 ri->version = cpu_to_je32(f->highest_version);
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 */
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)
62 struct jffs2_full_dnode *fn;
68 unsigned long cnt = 2;
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");
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;
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);
84 fn = jffs2_alloc_full_dnode();
86 return ERR_PTR(-ENOMEM);
88 /* check number of valid vecs */
89 if (!datalen || !data)
92 flash_ofs = write_ofs(c);
94 jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len);
96 if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(ri->version) < f->highest_version)) {
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));
105 ret = jffs2_flash_writev(c, vecs, cnt, flash_ofs, &retlen,
106 (alloc_mode==ALLOC_GC)?0:f->inocache->ino);
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);
112 /* Mark the space as dirtied */
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
119 jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*ri)+datalen), NULL);
121 printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", flash_ofs);
123 if (!retried && alloc_mode != ALLOC_NORETRY) {
124 /* Try to reallocate space and retry */
126 struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
130 D1(printk(KERN_DEBUG "Retrying failed write.\n"));
132 jffs2_dbg_acct_sanity_check(c,jeb);
133 jffs2_dbg_acct_paranoia_check(c, jeb);
135 if (alloc_mode == ALLOC_GC) {
136 ret = jffs2_reserve_space_gc(c, sizeof(*ri) + datalen, &dummy,
137 JFFS2_SUMMARY_INODE_SIZE);
141 jffs2_complete_reservation(c);
143 ret = jffs2_reserve_space(c, sizeof(*ri) + datalen, &dummy,
144 alloc_mode, JFFS2_SUMMARY_INODE_SIZE);
149 flash_ofs = write_ofs(c);
150 D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs));
152 jffs2_dbg_acct_sanity_check(c,jeb);
153 jffs2_dbg_acct_paranoia_check(c, jeb);
157 D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret));
159 /* Release the full_dnode which is now useless, and return */
160 jffs2_free_full_dnode(fn);
161 return ERR_PTR(ret?ret:-EIO);
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.
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;
173 flash_ofs |= REF_NORMAL;
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_PTR(PTR_ERR(hold_err));
182 fn->ofs = je32_to_cpu(ri->offset);
183 fn->size = je32_to_cpu(ri->dsize);
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)));
192 jffs2_dbg_acct_sanity_check(c,NULL);
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)
202 struct jffs2_full_dirent *fd;
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)));
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");
218 vecs[0].iov_base = rd;
219 vecs[0].iov_len = sizeof(*rd);
220 vecs[1].iov_base = (unsigned char *)name;
221 vecs[1].iov_len = namelen;
223 fd = jffs2_alloc_full_dirent(namelen+1);
225 return ERR_PTR(-ENOMEM);
227 fd->version = je32_to_cpu(rd->version);
228 fd->ino = je32_to_cpu(rd->ino);
229 fd->nhash = full_name_hash(name, strlen(name));
231 memcpy(fd->name, name, namelen);
235 flash_ofs = write_ofs(c);
237 jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len);
239 if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(rd->version) < f->highest_version)) {
241 D1(printk(KERN_DEBUG "jffs2_write_dirent : dirent_version %d, "
242 "highest version %d -> updating dirent\n",
243 je32_to_cpu(rd->version), f->highest_version));
244 rd->version = cpu_to_je32(++f->highest_version);
245 fd->version = je32_to_cpu(rd->version);
246 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
249 ret = jffs2_flash_writev(c, vecs, 2, flash_ofs, &retlen,
250 (alloc_mode==ALLOC_GC)?0:je32_to_cpu(rd->pino));
251 if (ret || (retlen != sizeof(*rd) + namelen)) {
252 printk(KERN_NOTICE "Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
253 sizeof(*rd)+namelen, flash_ofs, ret, retlen);
254 /* Mark the space as dirtied */
256 jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*rd)+namelen), NULL);
258 printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", flash_ofs);
261 /* Try to reallocate space and retry */
263 struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
267 D1(printk(KERN_DEBUG "Retrying failed write.\n"));
269 jffs2_dbg_acct_sanity_check(c,jeb);
270 jffs2_dbg_acct_paranoia_check(c, jeb);
272 if (alloc_mode == ALLOC_GC) {
273 ret = jffs2_reserve_space_gc(c, sizeof(*rd) + namelen, &dummy,
274 JFFS2_SUMMARY_DIRENT_SIZE(namelen));
278 jffs2_complete_reservation(c);
280 ret = jffs2_reserve_space(c, sizeof(*rd) + namelen, &dummy,
281 alloc_mode, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
286 flash_ofs = write_ofs(c);
287 D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs));
288 jffs2_dbg_acct_sanity_check(c,jeb);
289 jffs2_dbg_acct_paranoia_check(c, jeb);
292 D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret));
294 /* Release the full_dnode which is now useless, and return */
295 jffs2_free_full_dirent(fd);
296 return ERR_PTR(ret?ret:-EIO);
298 /* Mark the space used */
299 fd->raw = jffs2_add_physical_node_ref(c, flash_ofs | REF_PRISTINE, PAD(sizeof(*rd)+namelen), f->inocache);
300 if (IS_ERR(fd->raw)) {
301 void *hold_err = fd->raw;
302 /* Release the full_dirent which is now useless, and return */
303 jffs2_free_full_dirent(fd);
304 return ERR_PTR(PTR_ERR(hold_err));
308 jffs2_dbg_acct_sanity_check(c,NULL);
314 /* The OS-specific code fills in the metadata in the jffs2_raw_inode for us, so that
315 we don't have to go digging in struct inode or its equivalent. It should set:
316 mode, uid, gid, (starting)isize, atime, ctime, mtime */
317 int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
318 struct jffs2_raw_inode *ri, unsigned char *buf,
319 uint32_t offset, uint32_t writelen, uint32_t *retlen)
322 uint32_t writtenlen = 0;
324 D1(printk(KERN_DEBUG "jffs2_write_inode_range(): Ino #%u, ofs 0x%x, len 0x%x\n",
325 f->inocache->ino, offset, writelen));
328 struct jffs2_full_dnode *fn;
329 unsigned char *comprbuf = NULL;
330 uint16_t comprtype = JFFS2_COMPR_NONE;
332 uint32_t datalen, cdatalen;
336 D2(printk(KERN_DEBUG "jffs2_commit_write() loop: 0x%x to write to 0x%x\n", writelen, offset));
338 ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN,
339 &alloclen, ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
341 D1(printk(KERN_DEBUG "jffs2_reserve_space returned %d\n", ret));
345 datalen = min_t(uint32_t, writelen, PAGE_CACHE_SIZE - (offset & (PAGE_CACHE_SIZE-1)));
346 cdatalen = min_t(uint32_t, alloclen - sizeof(*ri), datalen);
348 comprtype = jffs2_compress(c, f, buf, &comprbuf, &datalen, &cdatalen);
350 ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
351 ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
352 ri->totlen = cpu_to_je32(sizeof(*ri) + cdatalen);
353 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
355 ri->ino = cpu_to_je32(f->inocache->ino);
356 ri->version = cpu_to_je32(++f->highest_version);
357 ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen));
358 ri->offset = cpu_to_je32(offset);
359 ri->csize = cpu_to_je32(cdatalen);
360 ri->dsize = cpu_to_je32(datalen);
361 ri->compr = comprtype & 0xff;
362 ri->usercompr = (comprtype >> 8 ) & 0xff;
363 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
364 ri->data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
366 fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, ALLOC_NORETRY);
368 jffs2_free_comprbuf(comprbuf, buf);
373 jffs2_complete_reservation(c);
375 /* Write error to be retried */
377 D1(printk(KERN_DEBUG "Retrying node write in jffs2_write_inode_range()\n"));
382 ret = jffs2_add_full_dnode_to_inode(c, f, fn);
384 jffs2_mark_node_obsolete(c, f->metadata->raw);
385 jffs2_free_full_dnode(f->metadata);
390 D1(printk(KERN_DEBUG "Eep. add_full_dnode_to_inode() failed in commit_write, returned %d\n", ret));
391 jffs2_mark_node_obsolete(c, fn->raw);
392 jffs2_free_full_dnode(fn);
395 jffs2_complete_reservation(c);
399 jffs2_complete_reservation(c);
401 printk(KERN_WARNING "Eep. We didn't actually write any data in jffs2_write_inode_range()\n");
405 D1(printk(KERN_DEBUG "increasing writtenlen by %d\n", datalen));
406 writtenlen += datalen;
411 *retlen = writtenlen;
415 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)
417 struct jffs2_raw_dirent *rd;
418 struct jffs2_full_dnode *fn;
419 struct jffs2_full_dirent *fd;
423 /* Try to reserve enough space for both node and dirent.
424 * Just the node will do for now, though
426 ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL,
427 JFFS2_SUMMARY_INODE_SIZE);
428 D1(printk(KERN_DEBUG "jffs2_do_create(): reserved 0x%x bytes\n", alloclen));
434 ri->data_crc = cpu_to_je32(0);
435 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
437 fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL);
439 D1(printk(KERN_DEBUG "jffs2_do_create created file with mode 0x%x\n",
440 jemode_to_cpu(ri->mode)));
443 D1(printk(KERN_DEBUG "jffs2_write_dnode() failed\n"));
444 /* Eeek. Wave bye bye */
446 jffs2_complete_reservation(c);
449 /* No data here. Only a metadata node, which will be
450 obsoleted by the first data write
455 jffs2_complete_reservation(c);
456 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
457 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
461 D1(printk(KERN_DEBUG "jffs2_reserve_space() for dirent failed\n"));
465 rd = jffs2_alloc_raw_dirent();
467 /* Argh. Now we treat it like a normal delete */
468 jffs2_complete_reservation(c);
474 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
475 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
476 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
477 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
479 rd->pino = cpu_to_je32(dir_f->inocache->ino);
480 rd->version = cpu_to_je32(++dir_f->highest_version);
482 rd->mctime = ri->ctime;
485 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
486 rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
488 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL);
490 jffs2_free_raw_dirent(rd);
493 /* dirent failed to write. Delete the inode normally
494 as if it were the final unlink() */
495 jffs2_complete_reservation(c);
500 /* Link the fd into the inode's list, obsoleting an old
502 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
504 jffs2_complete_reservation(c);
511 int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f,
512 const char *name, int namelen, struct jffs2_inode_info *dead_f,
515 struct jffs2_raw_dirent *rd;
516 struct jffs2_full_dirent *fd;
520 if (!jffs2_can_mark_obsolete(c)) {
521 /* We can't mark stuff obsolete on the medium. We need to write a deletion dirent */
523 rd = jffs2_alloc_raw_dirent();
527 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
528 ALLOC_DELETION, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
530 jffs2_free_raw_dirent(rd);
536 /* Build a deletion node */
537 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
538 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
539 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
540 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
542 rd->pino = cpu_to_je32(dir_f->inocache->ino);
543 rd->version = cpu_to_je32(++dir_f->highest_version);
544 rd->ino = cpu_to_je32(0);
545 rd->mctime = cpu_to_je32(time);
547 rd->type = DT_UNKNOWN;
548 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
549 rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
551 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_DELETION);
553 jffs2_free_raw_dirent(rd);
556 jffs2_complete_reservation(c);
561 /* File it. This will mark the old one obsolete. */
562 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
565 struct jffs2_full_dirent **prev = &dir_f->dents;
566 uint32_t nhash = full_name_hash(name, namelen);
570 while ((*prev) && (*prev)->nhash <= nhash) {
571 if ((*prev)->nhash == nhash &&
572 !memcmp((*prev)->name, name, namelen) &&
573 !(*prev)->name[namelen]) {
574 struct jffs2_full_dirent *this = *prev;
576 D1(printk(KERN_DEBUG "Marking old dirent node (ino #%u) @%08x obsolete\n",
577 this->ino, ref_offset(this->raw)));
580 jffs2_mark_node_obsolete(c, (this->raw));
581 jffs2_free_full_dirent(this);
584 prev = &((*prev)->next);
589 /* dead_f is NULL if this was a rename not a real unlink */
590 /* Also catch the !f->inocache case, where there was a dirent
591 pointing to an inode which didn't exist. */
592 if (dead_f && dead_f->inocache) {
596 if (S_ISDIR(OFNI_EDONI_2SFFJ(dead_f)->i_mode)) {
597 while (dead_f->dents) {
598 /* There can be only deleted ones */
601 dead_f->dents = fd->next;
604 printk(KERN_WARNING "Deleting inode #%u with active dentry \"%s\"->ino #%u\n",
605 dead_f->inocache->ino, fd->name, fd->ino);
607 D1(printk(KERN_DEBUG "Removing deletion dirent for \"%s\" from dir ino #%u\n",
608 fd->name, dead_f->inocache->ino));
610 jffs2_mark_node_obsolete(c, fd->raw);
611 jffs2_free_full_dirent(fd);
615 dead_f->inocache->nlink--;
616 /* NB: Caller must set inode nlink if appropriate */
620 jffs2_complete_reservation(c);
626 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)
628 struct jffs2_raw_dirent *rd;
629 struct jffs2_full_dirent *fd;
633 rd = jffs2_alloc_raw_dirent();
637 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
638 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
640 jffs2_free_raw_dirent(rd);
646 /* Build a deletion node */
647 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
648 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
649 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
650 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
652 rd->pino = cpu_to_je32(dir_f->inocache->ino);
653 rd->version = cpu_to_je32(++dir_f->highest_version);
654 rd->ino = cpu_to_je32(ino);
655 rd->mctime = cpu_to_je32(time);
660 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
661 rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
663 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL);
665 jffs2_free_raw_dirent(rd);
668 jffs2_complete_reservation(c);
673 /* File it. This will mark the old one obsolete. */
674 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
676 jffs2_complete_reservation(c);