]>
git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - fs/jffs2/write.c
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
,
23 uint32_t mode
, struct jffs2_raw_inode
*ri
)
25 struct jffs2_inode_cache
*ic
;
27 ic
= jffs2_alloc_inode_cache();
32 memset(ic
, 0, sizeof(*ic
));
35 f
->inocache
->pino_nlink
= 1; /* Will be overwritten shortly for directories */
36 f
->inocache
->nodes
= (struct jffs2_raw_node_ref
*)f
->inocache
;
37 f
->inocache
->state
= INO_STATE_PRESENT
;
39 jffs2_add_ino_cache(c
, f
->inocache
);
40 D1(printk(KERN_DEBUG
"jffs2_do_new_inode(): Assigned ino# %d\n", f
->inocache
->ino
));
41 ri
->ino
= cpu_to_je32(f
->inocache
->ino
);
43 ri
->magic
= cpu_to_je16(JFFS2_MAGIC_BITMASK
);
44 ri
->nodetype
= cpu_to_je16(JFFS2_NODETYPE_INODE
);
45 ri
->totlen
= cpu_to_je32(PAD(sizeof(*ri
)));
46 ri
->hdr_crc
= cpu_to_je32(crc32(0, ri
, sizeof(struct jffs2_unknown_node
)-4));
47 ri
->mode
= cpu_to_jemode(mode
);
49 f
->highest_version
= 1;
50 ri
->version
= cpu_to_je32(f
->highest_version
);
55 /* jffs2_write_dnode - given a raw_inode, allocate a full_dnode for it,
56 write it to the flash, link it into the existing inode/fragment list */
58 struct jffs2_full_dnode
*jffs2_write_dnode(struct jffs2_sb_info
*c
, struct jffs2_inode_info
*f
,
59 struct jffs2_raw_inode
*ri
, const unsigned char *data
,
60 uint32_t datalen
, int alloc_mode
)
63 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 if (je32_to_cpu(ri
->totlen
) != sizeof(*ri
) + datalen
) {
82 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
);
85 fn
= jffs2_alloc_full_dnode();
87 return ERR_PTR(-ENOMEM
);
89 /* check number of valid vecs */
90 if (!datalen
|| !data
)
93 flash_ofs
= write_ofs(c
);
95 jffs2_dbg_prewrite_paranoia_check(c
, flash_ofs
, vecs
[0].iov_len
+ vecs
[1].iov_len
);
97 if ((alloc_mode
!=ALLOC_GC
) && (je32_to_cpu(ri
->version
) < f
->highest_version
)) {
99 D1(printk(KERN_DEBUG
"jffs2_write_dnode : dnode_version %d, "
100 "highest version %d -> updating dnode\n",
101 je32_to_cpu(ri
->version
), f
->highest_version
));
102 ri
->version
= cpu_to_je32(++f
->highest_version
);
103 ri
->node_crc
= cpu_to_je32(crc32(0, ri
, sizeof(*ri
)-8));
106 ret
= jffs2_flash_writev(c
, vecs
, cnt
, flash_ofs
, &retlen
,
107 (alloc_mode
==ALLOC_GC
)?0:f
->inocache
->ino
);
109 if (ret
|| (retlen
!= sizeof(*ri
) + datalen
)) {
110 printk(KERN_NOTICE
"Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
111 sizeof(*ri
)+datalen
, flash_ofs
, ret
, retlen
);
113 /* Mark the space as dirtied */
115 /* Don't change raw->size to match retlen. We may have
116 written the node header already, and only the data will
117 seem corrupted, in which case the scan would skip over
118 any node we write before the original intended end of
120 jffs2_add_physical_node_ref(c
, flash_ofs
| REF_OBSOLETE
, PAD(sizeof(*ri
)+datalen
), NULL
);
122 printk(KERN_NOTICE
"Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", flash_ofs
);
124 if (!retried
&& alloc_mode
!= ALLOC_NORETRY
) {
125 /* Try to reallocate space and retry */
127 struct jffs2_eraseblock
*jeb
= &c
->blocks
[flash_ofs
/ c
->sector_size
];
131 D1(printk(KERN_DEBUG
"Retrying failed write.\n"));
133 jffs2_dbg_acct_sanity_check(c
,jeb
);
134 jffs2_dbg_acct_paranoia_check(c
, jeb
);
136 if (alloc_mode
== ALLOC_GC
) {
137 ret
= jffs2_reserve_space_gc(c
, sizeof(*ri
) + datalen
, &dummy
,
138 JFFS2_SUMMARY_INODE_SIZE
);
141 mutex_unlock(&f
->sem
);
142 jffs2_complete_reservation(c
);
144 ret
= jffs2_reserve_space(c
, sizeof(*ri
) + datalen
, &dummy
,
145 alloc_mode
, JFFS2_SUMMARY_INODE_SIZE
);
150 flash_ofs
= write_ofs(c
);
151 D1(printk(KERN_DEBUG
"Allocated space at 0x%08x to retry failed write.\n", flash_ofs
));
153 jffs2_dbg_acct_sanity_check(c
,jeb
);
154 jffs2_dbg_acct_paranoia_check(c
, jeb
);
158 D1(printk(KERN_DEBUG
"Failed to allocate space to retry failed write: %d!\n", ret
));
160 /* Release the full_dnode which is now useless, and return */
161 jffs2_free_full_dnode(fn
);
162 return ERR_PTR(ret
?ret
:-EIO
);
164 /* Mark the space used */
165 /* If node covers at least a whole page, or if it starts at the
166 beginning of a page and runs to the end of the file, or if
167 it's a hole node, mark it REF_PRISTINE, else REF_NORMAL.
169 if ((je32_to_cpu(ri
->dsize
) >= PAGE_CACHE_SIZE
) ||
170 ( ((je32_to_cpu(ri
->offset
)&(PAGE_CACHE_SIZE
-1))==0) &&
171 (je32_to_cpu(ri
->dsize
)+je32_to_cpu(ri
->offset
) == je32_to_cpu(ri
->isize
)))) {
172 flash_ofs
|= REF_PRISTINE
;
174 flash_ofs
|= REF_NORMAL
;
176 fn
->raw
= jffs2_add_physical_node_ref(c
, flash_ofs
, PAD(sizeof(*ri
)+datalen
), f
->inocache
);
177 if (IS_ERR(fn
->raw
)) {
178 void *hold_err
= fn
->raw
;
179 /* Release the full_dnode which is now useless, and return */
180 jffs2_free_full_dnode(fn
);
181 return ERR_CAST(hold_err
);
183 fn
->ofs
= je32_to_cpu(ri
->offset
);
184 fn
->size
= je32_to_cpu(ri
->dsize
);
187 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",
188 flash_ofs
& ~3, flash_ofs
& 3, je32_to_cpu(ri
->dsize
),
189 je32_to_cpu(ri
->csize
), je32_to_cpu(ri
->node_crc
),
190 je32_to_cpu(ri
->data_crc
), je32_to_cpu(ri
->totlen
)));
193 jffs2_dbg_acct_sanity_check(c
,NULL
);
199 struct jffs2_full_dirent
*jffs2_write_dirent(struct jffs2_sb_info
*c
, struct jffs2_inode_info
*f
,
200 struct jffs2_raw_dirent
*rd
, const unsigned char *name
,
201 uint32_t namelen
, int alloc_mode
)
203 struct jffs2_full_dirent
*fd
;
210 D1(printk(KERN_DEBUG
"jffs2_write_dirent(ino #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x)\n",
211 je32_to_cpu(rd
->pino
), name
, name
, je32_to_cpu(rd
->ino
),
212 je32_to_cpu(rd
->name_crc
)));
214 D1(if(je32_to_cpu(rd
->hdr_crc
) != crc32(0, rd
, sizeof(struct jffs2_unknown_node
)-4)) {
215 printk(KERN_CRIT
"Eep. CRC not correct in jffs2_write_dirent()\n");
219 if (strnlen(name
, namelen
) != namelen
) {
220 /* This should never happen, but seems to have done on at least one
221 occasion: https://dev.laptop.org/ticket/4184 */
222 printk(KERN_CRIT
"Error in jffs2_write_dirent() -- name contains zero bytes!\n");
223 printk(KERN_CRIT
"Directory inode #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x\n",
224 je32_to_cpu(rd
->pino
), name
, name
, je32_to_cpu(rd
->ino
),
225 je32_to_cpu(rd
->name_crc
));
227 return ERR_PTR(-EIO
);
230 vecs
[0].iov_base
= rd
;
231 vecs
[0].iov_len
= sizeof(*rd
);
232 vecs
[1].iov_base
= (unsigned char *)name
;
233 vecs
[1].iov_len
= namelen
;
235 fd
= jffs2_alloc_full_dirent(namelen
+1);
237 return ERR_PTR(-ENOMEM
);
239 fd
->version
= je32_to_cpu(rd
->version
);
240 fd
->ino
= je32_to_cpu(rd
->ino
);
241 fd
->nhash
= full_name_hash(name
, namelen
);
243 memcpy(fd
->name
, name
, namelen
);
247 flash_ofs
= write_ofs(c
);
249 jffs2_dbg_prewrite_paranoia_check(c
, flash_ofs
, vecs
[0].iov_len
+ vecs
[1].iov_len
);
251 if ((alloc_mode
!=ALLOC_GC
) && (je32_to_cpu(rd
->version
) < f
->highest_version
)) {
253 D1(printk(KERN_DEBUG
"jffs2_write_dirent : dirent_version %d, "
254 "highest version %d -> updating dirent\n",
255 je32_to_cpu(rd
->version
), f
->highest_version
));
256 rd
->version
= cpu_to_je32(++f
->highest_version
);
257 fd
->version
= je32_to_cpu(rd
->version
);
258 rd
->node_crc
= cpu_to_je32(crc32(0, rd
, sizeof(*rd
)-8));
261 ret
= jffs2_flash_writev(c
, vecs
, 2, flash_ofs
, &retlen
,
262 (alloc_mode
==ALLOC_GC
)?0:je32_to_cpu(rd
->pino
));
263 if (ret
|| (retlen
!= sizeof(*rd
) + namelen
)) {
264 printk(KERN_NOTICE
"Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
265 sizeof(*rd
)+namelen
, flash_ofs
, ret
, retlen
);
266 /* Mark the space as dirtied */
268 jffs2_add_physical_node_ref(c
, flash_ofs
| REF_OBSOLETE
, PAD(sizeof(*rd
)+namelen
), NULL
);
270 printk(KERN_NOTICE
"Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", flash_ofs
);
273 /* Try to reallocate space and retry */
275 struct jffs2_eraseblock
*jeb
= &c
->blocks
[flash_ofs
/ c
->sector_size
];
279 D1(printk(KERN_DEBUG
"Retrying failed write.\n"));
281 jffs2_dbg_acct_sanity_check(c
,jeb
);
282 jffs2_dbg_acct_paranoia_check(c
, jeb
);
284 if (alloc_mode
== ALLOC_GC
) {
285 ret
= jffs2_reserve_space_gc(c
, sizeof(*rd
) + namelen
, &dummy
,
286 JFFS2_SUMMARY_DIRENT_SIZE(namelen
));
289 mutex_unlock(&f
->sem
);
290 jffs2_complete_reservation(c
);
292 ret
= jffs2_reserve_space(c
, sizeof(*rd
) + namelen
, &dummy
,
293 alloc_mode
, JFFS2_SUMMARY_DIRENT_SIZE(namelen
));
298 flash_ofs
= write_ofs(c
);
299 D1(printk(KERN_DEBUG
"Allocated space at 0x%08x to retry failed write.\n", flash_ofs
));
300 jffs2_dbg_acct_sanity_check(c
,jeb
);
301 jffs2_dbg_acct_paranoia_check(c
, jeb
);
304 D1(printk(KERN_DEBUG
"Failed to allocate space to retry failed write: %d!\n", ret
));
306 /* Release the full_dnode which is now useless, and return */
307 jffs2_free_full_dirent(fd
);
308 return ERR_PTR(ret
?ret
:-EIO
);
310 /* Mark the space used */
311 fd
->raw
= jffs2_add_physical_node_ref(c
, flash_ofs
| dirent_node_state(rd
),
312 PAD(sizeof(*rd
)+namelen
), f
->inocache
);
313 if (IS_ERR(fd
->raw
)) {
314 void *hold_err
= fd
->raw
;
315 /* Release the full_dirent which is now useless, and return */
316 jffs2_free_full_dirent(fd
);
317 return ERR_CAST(hold_err
);
321 jffs2_dbg_acct_sanity_check(c
,NULL
);
327 /* The OS-specific code fills in the metadata in the jffs2_raw_inode for us, so that
328 we don't have to go digging in struct inode or its equivalent. It should set:
329 mode, uid, gid, (starting)isize, atime, ctime, mtime */
330 int jffs2_write_inode_range(struct jffs2_sb_info
*c
, struct jffs2_inode_info
*f
,
331 struct jffs2_raw_inode
*ri
, unsigned char *buf
,
332 uint32_t offset
, uint32_t writelen
, uint32_t *retlen
)
335 uint32_t writtenlen
= 0;
337 D1(printk(KERN_DEBUG
"jffs2_write_inode_range(): Ino #%u, ofs 0x%x, len 0x%x\n",
338 f
->inocache
->ino
, offset
, writelen
));
341 struct jffs2_full_dnode
*fn
;
342 unsigned char *comprbuf
= NULL
;
343 uint16_t comprtype
= JFFS2_COMPR_NONE
;
345 uint32_t datalen
, cdatalen
;
349 D2(printk(KERN_DEBUG
"jffs2_commit_write() loop: 0x%x to write to 0x%x\n", writelen
, offset
));
351 ret
= jffs2_reserve_space(c
, sizeof(*ri
) + JFFS2_MIN_DATA_LEN
,
352 &alloclen
, ALLOC_NORMAL
, JFFS2_SUMMARY_INODE_SIZE
);
354 D1(printk(KERN_DEBUG
"jffs2_reserve_space returned %d\n", ret
));
358 datalen
= min_t(uint32_t, writelen
, PAGE_CACHE_SIZE
- (offset
& (PAGE_CACHE_SIZE
-1)));
359 cdatalen
= min_t(uint32_t, alloclen
- sizeof(*ri
), datalen
);
361 comprtype
= jffs2_compress(c
, f
, buf
, &comprbuf
, &datalen
, &cdatalen
);
363 ri
->magic
= cpu_to_je16(JFFS2_MAGIC_BITMASK
);
364 ri
->nodetype
= cpu_to_je16(JFFS2_NODETYPE_INODE
);
365 ri
->totlen
= cpu_to_je32(sizeof(*ri
) + cdatalen
);
366 ri
->hdr_crc
= cpu_to_je32(crc32(0, ri
, sizeof(struct jffs2_unknown_node
)-4));
368 ri
->ino
= cpu_to_je32(f
->inocache
->ino
);
369 ri
->version
= cpu_to_je32(++f
->highest_version
);
370 ri
->isize
= cpu_to_je32(max(je32_to_cpu(ri
->isize
), offset
+ datalen
));
371 ri
->offset
= cpu_to_je32(offset
);
372 ri
->csize
= cpu_to_je32(cdatalen
);
373 ri
->dsize
= cpu_to_je32(datalen
);
374 ri
->compr
= comprtype
& 0xff;
375 ri
->usercompr
= (comprtype
>> 8 ) & 0xff;
376 ri
->node_crc
= cpu_to_je32(crc32(0, ri
, sizeof(*ri
)-8));
377 ri
->data_crc
= cpu_to_je32(crc32(0, comprbuf
, cdatalen
));
379 fn
= jffs2_write_dnode(c
, f
, ri
, comprbuf
, cdatalen
, ALLOC_NORETRY
);
381 jffs2_free_comprbuf(comprbuf
, buf
);
385 mutex_unlock(&f
->sem
);
386 jffs2_complete_reservation(c
);
388 /* Write error to be retried */
390 D1(printk(KERN_DEBUG
"Retrying node write in jffs2_write_inode_range()\n"));
395 ret
= jffs2_add_full_dnode_to_inode(c
, f
, fn
);
397 jffs2_mark_node_obsolete(c
, f
->metadata
->raw
);
398 jffs2_free_full_dnode(f
->metadata
);
403 D1(printk(KERN_DEBUG
"Eep. add_full_dnode_to_inode() failed in commit_write, returned %d\n", ret
));
404 jffs2_mark_node_obsolete(c
, fn
->raw
);
405 jffs2_free_full_dnode(fn
);
407 mutex_unlock(&f
->sem
);
408 jffs2_complete_reservation(c
);
411 mutex_unlock(&f
->sem
);
412 jffs2_complete_reservation(c
);
414 printk(KERN_WARNING
"Eep. We didn't actually write any data in jffs2_write_inode_range()\n");
418 D1(printk(KERN_DEBUG
"increasing writtenlen by %d\n", datalen
));
419 writtenlen
+= datalen
;
424 *retlen
= writtenlen
;
428 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
)
430 struct jffs2_raw_dirent
*rd
;
431 struct jffs2_full_dnode
*fn
;
432 struct jffs2_full_dirent
*fd
;
436 /* Try to reserve enough space for both node and dirent.
437 * Just the node will do for now, though
439 ret
= jffs2_reserve_space(c
, sizeof(*ri
), &alloclen
, ALLOC_NORMAL
,
440 JFFS2_SUMMARY_INODE_SIZE
);
441 D1(printk(KERN_DEBUG
"jffs2_do_create(): reserved 0x%x bytes\n", alloclen
));
447 ri
->data_crc
= cpu_to_je32(0);
448 ri
->node_crc
= cpu_to_je32(crc32(0, ri
, sizeof(*ri
)-8));
450 fn
= jffs2_write_dnode(c
, f
, ri
, NULL
, 0, ALLOC_NORMAL
);
452 D1(printk(KERN_DEBUG
"jffs2_do_create created file with mode 0x%x\n",
453 jemode_to_cpu(ri
->mode
)));
456 D1(printk(KERN_DEBUG
"jffs2_write_dnode() failed\n"));
457 /* Eeek. Wave bye bye */
458 mutex_unlock(&f
->sem
);
459 jffs2_complete_reservation(c
);
462 /* No data here. Only a metadata node, which will be
463 obsoleted by the first data write
467 mutex_unlock(&f
->sem
);
468 jffs2_complete_reservation(c
);
470 ret
= jffs2_init_security(&f
->vfs_inode
, &dir_f
->vfs_inode
);
473 ret
= jffs2_init_acl_post(&f
->vfs_inode
);
477 ret
= jffs2_reserve_space(c
, sizeof(*rd
)+namelen
, &alloclen
,
478 ALLOC_NORMAL
, JFFS2_SUMMARY_DIRENT_SIZE(namelen
));
482 D1(printk(KERN_DEBUG
"jffs2_reserve_space() for dirent failed\n"));
486 rd
= jffs2_alloc_raw_dirent();
488 /* Argh. Now we treat it like a normal delete */
489 jffs2_complete_reservation(c
);
493 mutex_lock(&dir_f
->sem
);
495 rd
->magic
= cpu_to_je16(JFFS2_MAGIC_BITMASK
);
496 rd
->nodetype
= cpu_to_je16(JFFS2_NODETYPE_DIRENT
);
497 rd
->totlen
= cpu_to_je32(sizeof(*rd
) + namelen
);
498 rd
->hdr_crc
= cpu_to_je32(crc32(0, rd
, sizeof(struct jffs2_unknown_node
)-4));
500 rd
->pino
= cpu_to_je32(dir_f
->inocache
->ino
);
501 rd
->version
= cpu_to_je32(++dir_f
->highest_version
);
503 rd
->mctime
= ri
->ctime
;
506 rd
->node_crc
= cpu_to_je32(crc32(0, rd
, sizeof(*rd
)-8));
507 rd
->name_crc
= cpu_to_je32(crc32(0, name
, namelen
));
509 fd
= jffs2_write_dirent(c
, dir_f
, rd
, name
, namelen
, ALLOC_NORMAL
);
511 jffs2_free_raw_dirent(rd
);
514 /* dirent failed to write. Delete the inode normally
515 as if it were the final unlink() */
516 jffs2_complete_reservation(c
);
517 mutex_unlock(&dir_f
->sem
);
521 /* Link the fd into the inode's list, obsoleting an old
523 jffs2_add_fd_to_list(c
, fd
, &dir_f
->dents
);
525 jffs2_complete_reservation(c
);
526 mutex_unlock(&dir_f
->sem
);
532 int jffs2_do_unlink(struct jffs2_sb_info
*c
, struct jffs2_inode_info
*dir_f
,
533 const char *name
, int namelen
, struct jffs2_inode_info
*dead_f
,
536 struct jffs2_raw_dirent
*rd
;
537 struct jffs2_full_dirent
*fd
;
541 if (!jffs2_can_mark_obsolete(c
)) {
542 /* We can't mark stuff obsolete on the medium. We need to write a deletion dirent */
544 rd
= jffs2_alloc_raw_dirent();
548 ret
= jffs2_reserve_space(c
, sizeof(*rd
)+namelen
, &alloclen
,
549 ALLOC_DELETION
, JFFS2_SUMMARY_DIRENT_SIZE(namelen
));
551 jffs2_free_raw_dirent(rd
);
555 mutex_lock(&dir_f
->sem
);
557 /* Build a deletion node */
558 rd
->magic
= cpu_to_je16(JFFS2_MAGIC_BITMASK
);
559 rd
->nodetype
= cpu_to_je16(JFFS2_NODETYPE_DIRENT
);
560 rd
->totlen
= cpu_to_je32(sizeof(*rd
) + namelen
);
561 rd
->hdr_crc
= cpu_to_je32(crc32(0, rd
, sizeof(struct jffs2_unknown_node
)-4));
563 rd
->pino
= cpu_to_je32(dir_f
->inocache
->ino
);
564 rd
->version
= cpu_to_je32(++dir_f
->highest_version
);
565 rd
->ino
= cpu_to_je32(0);
566 rd
->mctime
= cpu_to_je32(time
);
568 rd
->type
= DT_UNKNOWN
;
569 rd
->node_crc
= cpu_to_je32(crc32(0, rd
, sizeof(*rd
)-8));
570 rd
->name_crc
= cpu_to_je32(crc32(0, name
, namelen
));
572 fd
= jffs2_write_dirent(c
, dir_f
, rd
, name
, namelen
, ALLOC_DELETION
);
574 jffs2_free_raw_dirent(rd
);
577 jffs2_complete_reservation(c
);
578 mutex_unlock(&dir_f
->sem
);
582 /* File it. This will mark the old one obsolete. */
583 jffs2_add_fd_to_list(c
, fd
, &dir_f
->dents
);
584 mutex_unlock(&dir_f
->sem
);
586 uint32_t nhash
= full_name_hash(name
, namelen
);
589 /* We don't actually want to reserve any space, but we do
590 want to be holding the alloc_sem when we write to flash */
591 mutex_lock(&c
->alloc_sem
);
592 mutex_lock(&dir_f
->sem
);
594 for (fd
= dir_f
->dents
; fd
; fd
= fd
->next
) {
595 if (fd
->nhash
== nhash
&&
596 !memcmp(fd
->name
, name
, namelen
) &&
597 !fd
->name
[namelen
]) {
599 D1(printk(KERN_DEBUG
"Marking old dirent node (ino #%u) @%08x obsolete\n",
600 fd
->ino
, ref_offset(fd
->raw
)));
601 jffs2_mark_node_obsolete(c
, fd
->raw
);
602 /* We don't want to remove it from the list immediately,
603 because that screws up getdents()/seek() semantics even
604 more than they're screwed already. Turn it into a
605 node-less deletion dirent instead -- a placeholder */
611 mutex_unlock(&dir_f
->sem
);
614 /* dead_f is NULL if this was a rename not a real unlink */
615 /* Also catch the !f->inocache case, where there was a dirent
616 pointing to an inode which didn't exist. */
617 if (dead_f
&& dead_f
->inocache
) {
619 mutex_lock(&dead_f
->sem
);
621 if (S_ISDIR(OFNI_EDONI_2SFFJ(dead_f
)->i_mode
)) {
622 while (dead_f
->dents
) {
623 /* There can be only deleted ones */
626 dead_f
->dents
= fd
->next
;
629 printk(KERN_WARNING
"Deleting inode #%u with active dentry \"%s\"->ino #%u\n",
630 dead_f
->inocache
->ino
, fd
->name
, fd
->ino
);
632 D1(printk(KERN_DEBUG
"Removing deletion dirent for \"%s\" from dir ino #%u\n",
633 fd
->name
, dead_f
->inocache
->ino
));
636 jffs2_mark_node_obsolete(c
, fd
->raw
);
637 jffs2_free_full_dirent(fd
);
639 dead_f
->inocache
->pino_nlink
= 0;
641 dead_f
->inocache
->pino_nlink
--;
642 /* NB: Caller must set inode nlink if appropriate */
643 mutex_unlock(&dead_f
->sem
);
646 jffs2_complete_reservation(c
);
652 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
)
654 struct jffs2_raw_dirent
*rd
;
655 struct jffs2_full_dirent
*fd
;
659 rd
= jffs2_alloc_raw_dirent();
663 ret
= jffs2_reserve_space(c
, sizeof(*rd
)+namelen
, &alloclen
,
664 ALLOC_NORMAL
, JFFS2_SUMMARY_DIRENT_SIZE(namelen
));
666 jffs2_free_raw_dirent(rd
);
670 mutex_lock(&dir_f
->sem
);
672 /* Build a deletion node */
673 rd
->magic
= cpu_to_je16(JFFS2_MAGIC_BITMASK
);
674 rd
->nodetype
= cpu_to_je16(JFFS2_NODETYPE_DIRENT
);
675 rd
->totlen
= cpu_to_je32(sizeof(*rd
) + namelen
);
676 rd
->hdr_crc
= cpu_to_je32(crc32(0, rd
, sizeof(struct jffs2_unknown_node
)-4));
678 rd
->pino
= cpu_to_je32(dir_f
->inocache
->ino
);
679 rd
->version
= cpu_to_je32(++dir_f
->highest_version
);
680 rd
->ino
= cpu_to_je32(ino
);
681 rd
->mctime
= cpu_to_je32(time
);
686 rd
->node_crc
= cpu_to_je32(crc32(0, rd
, sizeof(*rd
)-8));
687 rd
->name_crc
= cpu_to_je32(crc32(0, name
, namelen
));
689 fd
= jffs2_write_dirent(c
, dir_f
, rd
, name
, namelen
, ALLOC_NORMAL
);
691 jffs2_free_raw_dirent(rd
);
694 jffs2_complete_reservation(c
);
695 mutex_unlock(&dir_f
->sem
);
699 /* File it. This will mark the old one obsolete. */
700 jffs2_add_fd_to_list(c
, fd
, &dir_f
->dents
);
702 jffs2_complete_reservation(c
);
703 mutex_unlock(&dir_f
->sem
);