1
2
3
4
5
6
7
8
9
10
11
12#include <linux/kernel.h>
13#include <linux/fs.h>
14#include <linux/crc32.h>
15#include <linux/slab.h>
16#include <linux/pagemap.h>
17#include <linux/mtd/mtd.h>
18#include "nodelist.h"
19#include "compr.h"
20
21
22int jffs2_do_new_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
23 uint32_t mode, struct jffs2_raw_inode *ri)
24{
25 struct jffs2_inode_cache *ic;
26
27 ic = jffs2_alloc_inode_cache();
28 if (!ic) {
29 return -ENOMEM;
30 }
31
32 memset(ic, 0, sizeof(*ic));
33
34 f->inocache = ic;
35 f->inocache->pino_nlink = 1;
36 f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache;
37 f->inocache->state = INO_STATE_PRESENT;
38
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);
42
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);
48
49 f->highest_version = 1;
50 ri->version = cpu_to_je32(f->highest_version);
51
52 return 0;
53}
54
55
56
57
58struct 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)
61
62{
63 struct jffs2_full_dnode *fn;
64 size_t retlen;
65 uint32_t flash_ofs;
66 struct kvec vecs[2];
67 int ret;
68 int retried = 0;
69 unsigned long cnt = 2;
70
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");
73 BUG();
74 }
75 );
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;
80
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);
83 }
84
85 fn = jffs2_alloc_full_dnode();
86 if (!fn)
87 return ERR_PTR(-ENOMEM);
88
89
90 if (!datalen || !data)
91 cnt = 1;
92 retry:
93 flash_ofs = write_ofs(c);
94
95 jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len);
96
97 if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(ri->version) < f->highest_version)) {
98 BUG_ON(!retried);
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));
104 }
105
106 ret = jffs2_flash_writev(c, vecs, cnt, flash_ofs, &retlen,
107 (alloc_mode==ALLOC_GC)?0:f->inocache->ino);
108
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);
112
113
114 if (retlen) {
115
116
117
118
119
120 jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*ri)+datalen), NULL);
121 } else {
122 printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", flash_ofs);
123 }
124 if (!retried && alloc_mode != ALLOC_NORETRY) {
125
126 uint32_t dummy;
127 struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
128
129 retried = 1;
130
131 D1(printk(KERN_DEBUG "Retrying failed write.\n"));
132
133 jffs2_dbg_acct_sanity_check(c,jeb);
134 jffs2_dbg_acct_paranoia_check(c, jeb);
135
136 if (alloc_mode == ALLOC_GC) {
137 ret = jffs2_reserve_space_gc(c, sizeof(*ri) + datalen, &dummy,
138 JFFS2_SUMMARY_INODE_SIZE);
139 } else {
140
141 mutex_unlock(&f->sem);
142 jffs2_complete_reservation(c);
143
144 ret = jffs2_reserve_space(c, sizeof(*ri) + datalen, &dummy,
145 alloc_mode, JFFS2_SUMMARY_INODE_SIZE);
146 mutex_lock(&f->sem);
147 }
148
149 if (!ret) {
150 flash_ofs = write_ofs(c);
151 D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs));
152
153 jffs2_dbg_acct_sanity_check(c,jeb);
154 jffs2_dbg_acct_paranoia_check(c, jeb);
155
156 goto retry;
157 }
158 D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret));
159 }
160
161 jffs2_free_full_dnode(fn);
162 return ERR_PTR(ret?ret:-EIO);
163 }
164
165
166
167
168
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;
173 } else {
174 flash_ofs |= REF_NORMAL;
175 }
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
180 jffs2_free_full_dnode(fn);
181 return ERR_CAST(hold_err);
182 }
183 fn->ofs = je32_to_cpu(ri->offset);
184 fn->size = je32_to_cpu(ri->dsize);
185 fn->frags = 0;
186
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)));
191
192 if (retried) {
193 jffs2_dbg_acct_sanity_check(c,NULL);
194 }
195
196 return fn;
197}
198
199struct 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)
202{
203 struct jffs2_full_dirent *fd;
204 size_t retlen;
205 struct kvec vecs[2];
206 uint32_t flash_ofs;
207 int retried = 0;
208 int ret;
209
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)));
213
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");
216 BUG();
217 });
218
219 if (strnlen(name, namelen) != namelen) {
220
221
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));
226 WARN_ON(1);
227 return ERR_PTR(-EIO);
228 }
229
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;
234
235 fd = jffs2_alloc_full_dirent(namelen+1);
236 if (!fd)
237 return ERR_PTR(-ENOMEM);
238
239 fd->version = je32_to_cpu(rd->version);
240 fd->ino = je32_to_cpu(rd->ino);
241 fd->nhash = full_name_hash(name, namelen);
242 fd->type = rd->type;
243 memcpy(fd->name, name, namelen);
244 fd->name[namelen]=0;
245
246 retry:
247 flash_ofs = write_ofs(c);
248
249 jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len);
250
251 if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(rd->version) < f->highest_version)) {
252 BUG_ON(!retried);
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));
259 }
260
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
267 if (retlen) {
268 jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*rd)+namelen), NULL);
269 } else {
270 printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", flash_ofs);
271 }
272 if (!retried) {
273
274 uint32_t dummy;
275 struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
276
277 retried = 1;
278
279 D1(printk(KERN_DEBUG "Retrying failed write.\n"));
280
281 jffs2_dbg_acct_sanity_check(c,jeb);
282 jffs2_dbg_acct_paranoia_check(c, jeb);
283
284 if (alloc_mode == ALLOC_GC) {
285 ret = jffs2_reserve_space_gc(c, sizeof(*rd) + namelen, &dummy,
286 JFFS2_SUMMARY_DIRENT_SIZE(namelen));
287 } else {
288
289 mutex_unlock(&f->sem);
290 jffs2_complete_reservation(c);
291
292 ret = jffs2_reserve_space(c, sizeof(*rd) + namelen, &dummy,
293 alloc_mode, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
294 mutex_lock(&f->sem);
295 }
296
297 if (!ret) {
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);
302 goto retry;
303 }
304 D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret));
305 }
306
307 jffs2_free_full_dirent(fd);
308 return ERR_PTR(ret?ret:-EIO);
309 }
310
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
316 jffs2_free_full_dirent(fd);
317 return ERR_CAST(hold_err);
318 }
319
320 if (retried) {
321 jffs2_dbg_acct_sanity_check(c,NULL);
322 }
323
324 return fd;
325}
326
327
328
329
330int 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)
333{
334 int ret = 0;
335 uint32_t writtenlen = 0;
336
337 D1(printk(KERN_DEBUG "jffs2_write_inode_range(): Ino #%u, ofs 0x%x, len 0x%x\n",
338 f->inocache->ino, offset, writelen));
339
340 while(writelen) {
341 struct jffs2_full_dnode *fn;
342 unsigned char *comprbuf = NULL;
343 uint16_t comprtype = JFFS2_COMPR_NONE;
344 uint32_t alloclen;
345 uint32_t datalen, cdatalen;
346 int retried = 0;
347
348 retry:
349 D2(printk(KERN_DEBUG "jffs2_commit_write() loop: 0x%x to write to 0x%x\n", writelen, offset));
350
351 ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN,
352 &alloclen, ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
353 if (ret) {
354 D1(printk(KERN_DEBUG "jffs2_reserve_space returned %d\n", ret));
355 break;
356 }
357 mutex_lock(&f->sem);
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);
360
361 comprtype = jffs2_compress(c, f, buf, &comprbuf, &datalen, &cdatalen);
362
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));
367
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));
378
379 fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, ALLOC_NORETRY);
380
381 jffs2_free_comprbuf(comprbuf, buf);
382
383 if (IS_ERR(fn)) {
384 ret = PTR_ERR(fn);
385 mutex_unlock(&f->sem);
386 jffs2_complete_reservation(c);
387 if (!retried) {
388
389 retried = 1;
390 D1(printk(KERN_DEBUG "Retrying node write in jffs2_write_inode_range()\n"));
391 goto retry;
392 }
393 break;
394 }
395 ret = jffs2_add_full_dnode_to_inode(c, f, fn);
396 if (f->metadata) {
397 jffs2_mark_node_obsolete(c, f->metadata->raw);
398 jffs2_free_full_dnode(f->metadata);
399 f->metadata = NULL;
400 }
401 if (ret) {
402
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);
406
407 mutex_unlock(&f->sem);
408 jffs2_complete_reservation(c);
409 break;
410 }
411 mutex_unlock(&f->sem);
412 jffs2_complete_reservation(c);
413 if (!datalen) {
414 printk(KERN_WARNING "Eep. We didn't actually write any data in jffs2_write_inode_range()\n");
415 ret = -EIO;
416 break;
417 }
418 D1(printk(KERN_DEBUG "increasing writtenlen by %d\n", datalen));
419 writtenlen += datalen;
420 offset += datalen;
421 writelen -= datalen;
422 buf += datalen;
423 }
424 *retlen = writtenlen;
425 return ret;
426}
427
428int 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)
429{
430 struct jffs2_raw_dirent *rd;
431 struct jffs2_full_dnode *fn;
432 struct jffs2_full_dirent *fd;
433 uint32_t alloclen;
434 int ret;
435
436
437
438
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));
442 if (ret)
443 return ret;
444
445 mutex_lock(&f->sem);
446
447 ri->data_crc = cpu_to_je32(0);
448 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
449
450 fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL);
451
452 D1(printk(KERN_DEBUG "jffs2_do_create created file with mode 0x%x\n",
453 jemode_to_cpu(ri->mode)));
454
455 if (IS_ERR(fn)) {
456 D1(printk(KERN_DEBUG "jffs2_write_dnode() failed\n"));
457
458 mutex_unlock(&f->sem);
459 jffs2_complete_reservation(c);
460 return PTR_ERR(fn);
461 }
462
463
464
465 f->metadata = fn;
466
467 mutex_unlock(&f->sem);
468 jffs2_complete_reservation(c);
469
470 ret = jffs2_init_security(&f->vfs_inode, &dir_f->vfs_inode);
471 if (ret)
472 return ret;
473 ret = jffs2_init_acl_post(&f->vfs_inode);
474 if (ret)
475 return ret;
476
477 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
478 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
479
480 if (ret) {
481
482 D1(printk(KERN_DEBUG "jffs2_reserve_space() for dirent failed\n"));
483 return ret;
484 }
485
486 rd = jffs2_alloc_raw_dirent();
487 if (!rd) {
488
489 jffs2_complete_reservation(c);
490 return -ENOMEM;
491 }
492
493 mutex_lock(&dir_f->sem);
494
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));
499
500 rd->pino = cpu_to_je32(dir_f->inocache->ino);
501 rd->version = cpu_to_je32(++dir_f->highest_version);
502 rd->ino = ri->ino;
503 rd->mctime = ri->ctime;
504 rd->nsize = namelen;
505 rd->type = DT_REG;
506 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
507 rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
508
509 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL);
510
511 jffs2_free_raw_dirent(rd);
512
513 if (IS_ERR(fd)) {
514
515
516 jffs2_complete_reservation(c);
517 mutex_unlock(&dir_f->sem);
518 return PTR_ERR(fd);
519 }
520
521
522
523 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
524
525 jffs2_complete_reservation(c);
526 mutex_unlock(&dir_f->sem);
527
528 return 0;
529}
530
531
532int 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,
534 uint32_t time)
535{
536 struct jffs2_raw_dirent *rd;
537 struct jffs2_full_dirent *fd;
538 uint32_t alloclen;
539 int ret;
540
541 if (!jffs2_can_mark_obsolete(c)) {
542
543
544 rd = jffs2_alloc_raw_dirent();
545 if (!rd)
546 return -ENOMEM;
547
548 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
549 ALLOC_DELETION, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
550 if (ret) {
551 jffs2_free_raw_dirent(rd);
552 return ret;
553 }
554
555 mutex_lock(&dir_f->sem);
556
557
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));
562
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);
567 rd->nsize = namelen;
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));
571
572 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_DELETION);
573
574 jffs2_free_raw_dirent(rd);
575
576 if (IS_ERR(fd)) {
577 jffs2_complete_reservation(c);
578 mutex_unlock(&dir_f->sem);
579 return PTR_ERR(fd);
580 }
581
582
583 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
584 mutex_unlock(&dir_f->sem);
585 } else {
586 uint32_t nhash = full_name_hash(name, namelen);
587
588 fd = dir_f->dents;
589
590
591 mutex_lock(&c->alloc_sem);
592 mutex_lock(&dir_f->sem);
593
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]) {
598
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
603
604
605
606 fd->raw = NULL;
607 fd->ino = 0;
608 break;
609 }
610 }
611 mutex_unlock(&dir_f->sem);
612 }
613
614
615
616
617 if (dead_f && dead_f->inocache) {
618
619 mutex_lock(&dead_f->sem);
620
621 if (S_ISDIR(OFNI_EDONI_2SFFJ(dead_f)->i_mode)) {
622 while (dead_f->dents) {
623
624 fd = dead_f->dents;
625
626 dead_f->dents = fd->next;
627
628 if (fd->ino) {
629 printk(KERN_WARNING "Deleting inode #%u with active dentry \"%s\"->ino #%u\n",
630 dead_f->inocache->ino, fd->name, fd->ino);
631 } else {
632 D1(printk(KERN_DEBUG "Removing deletion dirent for \"%s\" from dir ino #%u\n",
633 fd->name, dead_f->inocache->ino));
634 }
635 if (fd->raw)
636 jffs2_mark_node_obsolete(c, fd->raw);
637 jffs2_free_full_dirent(fd);
638 }
639 dead_f->inocache->pino_nlink = 0;
640 } else
641 dead_f->inocache->pino_nlink--;
642
643 mutex_unlock(&dead_f->sem);
644 }
645
646 jffs2_complete_reservation(c);
647
648 return 0;
649}
650
651
652int 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)
653{
654 struct jffs2_raw_dirent *rd;
655 struct jffs2_full_dirent *fd;
656 uint32_t alloclen;
657 int ret;
658
659 rd = jffs2_alloc_raw_dirent();
660 if (!rd)
661 return -ENOMEM;
662
663 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
664 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
665 if (ret) {
666 jffs2_free_raw_dirent(rd);
667 return ret;
668 }
669
670 mutex_lock(&dir_f->sem);
671
672
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));
677
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);
682 rd->nsize = namelen;
683
684 rd->type = type;
685
686 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
687 rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
688
689 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL);
690
691 jffs2_free_raw_dirent(rd);
692
693 if (IS_ERR(fd)) {
694 jffs2_complete_reservation(c);
695 mutex_unlock(&dir_f->sem);
696 return PTR_ERR(fd);
697 }
698
699
700 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
701
702 jffs2_complete_reservation(c);
703 mutex_unlock(&dir_f->sem);
704
705 return 0;
706}
707