?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
paravirt: clean up lazy mode handling
[linux-2.6/mini2440.git] / fs / jffs2 / write.c
blob664c164aa67c19bef7583ce6fa7014cc715ffef5
1 /*
2 * JFFS2 -- Journalling Flash File System, Version 2.
3 *
4 * Copyright © 2001-2007 Red Hat, Inc.
5 *
6 * Created by David Woodhouse <dwmw2@infradead.org>
7 *
8 * For licensing information, see the file 'LICENCE' in this directory.
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
22 int jffs2_do_new_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, uint32_t mode, struct jffs2_raw_inode *ri)
23 {
24 struct jffs2_inode_cache *ic;
25
26 ic = jffs2_alloc_inode_cache();
27 if (!ic) {
28 return -ENOMEM;
29 }
30
31 memset(ic, 0, sizeof(*ic));
32
33 f->inocache = ic;
34 f->inocache->nlink = 1;
35 f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache;
36 f->inocache->state = INO_STATE_PRESENT;
37
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);
41
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);
47
48 f->highest_version = 1;
49 ri->version = cpu_to_je32(f->highest_version);
50
51 return 0;
52 }
53
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 */
56
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)
60
61 {
62 struct jffs2_full_dnode *fn;
63 size_t retlen;
64 uint32_t flash_ofs;
65 struct kvec vecs[2];
66 int ret;
67 int retried = 0;
68 unsigned long cnt = 2;
69
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");
72 BUG();
73 }
74 );
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;
79
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);
82 }
83
84 fn = jffs2_alloc_full_dnode();
85 if (!fn)
86 return ERR_PTR(-ENOMEM);
87
88 /* check number of valid vecs */
89 if (!datalen || !data)
90 cnt = 1;
91 retry:
92 flash_ofs = write_ofs(c);
93
94 jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len);
95
96 if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(ri->version) < f->highest_version)) {
97 BUG_ON(!retried);
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));
103 }
104
105 ret = jffs2_flash_writev(c, vecs, cnt, flash_ofs, &retlen,
106 (alloc_mode==ALLOC_GC)?0:f->inocache->ino);
107
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);
111
112 /* Mark the space as dirtied */
113 if (retlen) {
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
118 this node */
119 jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*ri)+datalen), NULL);
120 } else {
121 printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", flash_ofs);
122 }
123 if (!retried && alloc_mode != ALLOC_NORETRY) {
124 /* Try to reallocate space and retry */
125 uint32_t dummy;
126 struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
127
128 retried = 1;
129
130 D1(printk(KERN_DEBUG "Retrying failed write.\n"));
131
132 jffs2_dbg_acct_sanity_check(c,jeb);
133 jffs2_dbg_acct_paranoia_check(c, jeb);
134
135 if (alloc_mode == ALLOC_GC) {
136 ret = jffs2_reserve_space_gc(c, sizeof(*ri) + datalen, &dummy,
137 JFFS2_SUMMARY_INODE_SIZE);
138 } else {
139 /* Locking pain */
140 up(&f->sem);
141 jffs2_complete_reservation(c);
142
143 ret = jffs2_reserve_space(c, sizeof(*ri) + datalen, &dummy,
144 alloc_mode, JFFS2_SUMMARY_INODE_SIZE);
145 down(&f->sem);
146 }
147
148 if (!ret) {
149 flash_ofs = write_ofs(c);
150 D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs));
151
152 jffs2_dbg_acct_sanity_check(c,jeb);
153 jffs2_dbg_acct_paranoia_check(c, jeb);
154
155 goto retry;
156 }
157 D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret));
158 }
159 /* Release the full_dnode which is now useless, and return */
160 jffs2_free_full_dnode(fn);
161 return ERR_PTR(ret?ret:-EIO);
162 }
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.
167 */
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;
172 } else {
173 flash_ofs |= REF_NORMAL;
174 }
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));
181 }
182 fn->ofs = je32_to_cpu(ri->offset);
183 fn->size = je32_to_cpu(ri->dsize);
184 fn->frags = 0;
185
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)));
190
191 if (retried) {
192 jffs2_dbg_acct_sanity_check(c,NULL);
193 }
194
195 return fn;
196 }
197
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)
201 {
202 struct jffs2_full_dirent *fd;
203 size_t retlen;
204 struct kvec vecs[2];
205 uint32_t flash_ofs;
206 int retried = 0;
207 int ret;
208
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)));
212
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");
215 BUG();
216 });
217
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;
222
223 fd = jffs2_alloc_full_dirent(namelen+1);
224 if (!fd)
225 return ERR_PTR(-ENOMEM);
226
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));
230 fd->type = rd->type;
231 memcpy(fd->name, name, namelen);
232 fd->name[namelen]=0;
233
234 retry:
235 flash_ofs = write_ofs(c);
236
237 jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len);
238
239 if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(rd->version) < f->highest_version)) {
240 BUG_ON(!retried);
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));
247 }
248
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 */
255 if (retlen) {
256 jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*rd)+namelen), NULL);
257 } else {
258 printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", flash_ofs);
259 }
260 if (!retried) {
261 /* Try to reallocate space and retry */
262 uint32_t dummy;
263 struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
264
265 retried = 1;
266
267 D1(printk(KERN_DEBUG "Retrying failed write.\n"));
268
269 jffs2_dbg_acct_sanity_check(c,jeb);
270 jffs2_dbg_acct_paranoia_check(c, jeb);
271
272 if (alloc_mode == ALLOC_GC) {
273 ret = jffs2_reserve_space_gc(c, sizeof(*rd) + namelen, &dummy,
274 JFFS2_SUMMARY_DIRENT_SIZE(namelen));
275 } else {
276 /* Locking pain */
277 up(&f->sem);
278 jffs2_complete_reservation(c);
279
280 ret = jffs2_reserve_space(c, sizeof(*rd) + namelen, &dummy,
281 alloc_mode, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
282 down(&f->sem);
283 }
284
285 if (!ret) {
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);
290 goto retry;
291 }
292 D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret));
293 }
294 /* Release the full_dnode which is now useless, and return */
295 jffs2_free_full_dirent(fd);
296 return ERR_PTR(ret?ret:-EIO);
297 }
298 /* Mark the space used */
299 fd->raw = jffs2_add_physical_node_ref(c, flash_ofs | dirent_node_state(rd),
300 PAD(sizeof(*rd)+namelen), f->inocache);
301 if (IS_ERR(fd->raw)) {
302 void *hold_err = fd->raw;
303 /* Release the full_dirent which is now useless, and return */
304 jffs2_free_full_dirent(fd);
305 return ERR_PTR(PTR_ERR(hold_err));
306 }
307
308 if (retried) {
309 jffs2_dbg_acct_sanity_check(c,NULL);
310 }
311
312 return fd;
313 }
314
315 /* The OS-specific code fills in the metadata in the jffs2_raw_inode for us, so that
316 we don't have to go digging in struct inode or its equivalent. It should set:
317 mode, uid, gid, (starting)isize, atime, ctime, mtime */
318 int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
319 struct jffs2_raw_inode *ri, unsigned char *buf,
320 uint32_t offset, uint32_t writelen, uint32_t *retlen)
321 {
322 int ret = 0;
323 uint32_t writtenlen = 0;
324
325 D1(printk(KERN_DEBUG "jffs2_write_inode_range(): Ino #%u, ofs 0x%x, len 0x%x\n",
326 f->inocache->ino, offset, writelen));
327
328 while(writelen) {
329 struct jffs2_full_dnode *fn;
330 unsigned char *comprbuf = NULL;
331 uint16_t comprtype = JFFS2_COMPR_NONE;
332 uint32_t alloclen;
333 uint32_t datalen, cdatalen;
334 int retried = 0;
335
336 retry:
337 D2(printk(KERN_DEBUG "jffs2_commit_write() loop: 0x%x to write to 0x%x\n", writelen, offset));
338
339 ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN,
340 &alloclen, ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
341 if (ret) {
342 D1(printk(KERN_DEBUG "jffs2_reserve_space returned %d\n", ret));
343 break;
344 }
345 down(&f->sem);
346 datalen = min_t(uint32_t, writelen, PAGE_CACHE_SIZE - (offset & (PAGE_CACHE_SIZE-1)));
347 cdatalen = min_t(uint32_t, alloclen - sizeof(*ri), datalen);
348
349 comprtype = jffs2_compress(c, f, buf, &comprbuf, &datalen, &cdatalen);
350
351 ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
352 ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
353 ri->totlen = cpu_to_je32(sizeof(*ri) + cdatalen);
354 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
355
356 ri->ino = cpu_to_je32(f->inocache->ino);
357 ri->version = cpu_to_je32(++f->highest_version);
358 ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen));
359 ri->offset = cpu_to_je32(offset);
360 ri->csize = cpu_to_je32(cdatalen);
361 ri->dsize = cpu_to_je32(datalen);
362 ri->compr = comprtype & 0xff;
363 ri->usercompr = (comprtype >> 8 ) & 0xff;
364 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
365 ri->data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
366
367 fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, ALLOC_NORETRY);
368
369 jffs2_free_comprbuf(comprbuf, buf);
370
371 if (IS_ERR(fn)) {
372 ret = PTR_ERR(fn);
373 up(&f->sem);
374 jffs2_complete_reservation(c);
375 if (!retried) {
376 /* Write error to be retried */
377 retried = 1;
378 D1(printk(KERN_DEBUG "Retrying node write in jffs2_write_inode_range()\n"));
379 goto retry;
380 }
381 break;
382 }
383 ret = jffs2_add_full_dnode_to_inode(c, f, fn);
384 if (f->metadata) {
385 jffs2_mark_node_obsolete(c, f->metadata->raw);
386 jffs2_free_full_dnode(f->metadata);
387 f->metadata = NULL;
388 }
389 if (ret) {
390 /* Eep */
391 D1(printk(KERN_DEBUG "Eep. add_full_dnode_to_inode() failed in commit_write, returned %d\n", ret));
392 jffs2_mark_node_obsolete(c, fn->raw);
393 jffs2_free_full_dnode(fn);
394
395 up(&f->sem);
396 jffs2_complete_reservation(c);
397 break;
398 }
399 up(&f->sem);
400 jffs2_complete_reservation(c);
401 if (!datalen) {
402 printk(KERN_WARNING "Eep. We didn't actually write any data in jffs2_write_inode_range()\n");
403 ret = -EIO;
404 break;
405 }
406 D1(printk(KERN_DEBUG "increasing writtenlen by %d\n", datalen));
407 writtenlen += datalen;
408 offset += datalen;
409 writelen -= datalen;
410 buf += datalen;
411 }
412 *retlen = writtenlen;
413 return ret;
414 }
415
416 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 {
418 struct jffs2_raw_dirent *rd;
419 struct jffs2_full_dnode *fn;
420 struct jffs2_full_dirent *fd;
421 uint32_t alloclen;
422 int ret;
423
424 /* Try to reserve enough space for both node and dirent.
425 * Just the node will do for now, though
426 */
427 ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL,
428 JFFS2_SUMMARY_INODE_SIZE);
429 D1(printk(KERN_DEBUG "jffs2_do_create(): reserved 0x%x bytes\n", alloclen));
430 if (ret) {
431 up(&f->sem);
432 return ret;
433 }
434
435 ri->data_crc = cpu_to_je32(0);
436 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
437
438 fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL);
439
440 D1(printk(KERN_DEBUG "jffs2_do_create created file with mode 0x%x\n",
441 jemode_to_cpu(ri->mode)));
442
443 if (IS_ERR(fn)) {
444 D1(printk(KERN_DEBUG "jffs2_write_dnode() failed\n"));
445 /* Eeek. Wave bye bye */
446 up(&f->sem);
447 jffs2_complete_reservation(c);
448 return PTR_ERR(fn);
449 }
450 /* No data here. Only a metadata node, which will be
451 obsoleted by the first data write
452 */
453 f->metadata = fn;
454
455 up(&f->sem);
456 jffs2_complete_reservation(c);
457 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
458 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
459
460 if (ret) {
461 /* Eep. */
462 D1(printk(KERN_DEBUG "jffs2_reserve_space() for dirent failed\n"));
463 return ret;
464 }
465
466 rd = jffs2_alloc_raw_dirent();
467 if (!rd) {
468 /* Argh. Now we treat it like a normal delete */
469 jffs2_complete_reservation(c);
470 return -ENOMEM;
471 }
472
473 down(&dir_f->sem);
474
475 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
476 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
477 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
478 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
479
480 rd->pino = cpu_to_je32(dir_f->inocache->ino);
481 rd->version = cpu_to_je32(++dir_f->highest_version);
482 rd->ino = ri->ino;
483 rd->mctime = ri->ctime;
484 rd->nsize = namelen;
485 rd->type = DT_REG;
486 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
487 rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
488
489 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL);
490
491 jffs2_free_raw_dirent(rd);
492
493 if (IS_ERR(fd)) {
494 /* dirent failed to write. Delete the inode normally
495 as if it were the final unlink() */
496 jffs2_complete_reservation(c);
497 up(&dir_f->sem);
498 return PTR_ERR(fd);
499 }
500
501 /* Link the fd into the inode's list, obsoleting an old
502 one if necessary. */
503 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
504
505 jffs2_complete_reservation(c);
506 up(&dir_f->sem);
507
508 return 0;
509 }
510
511
512 int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f,
513 const char *name, int namelen, struct jffs2_inode_info *dead_f,
514 uint32_t time)
515 {
516 struct jffs2_raw_dirent *rd;
517 struct jffs2_full_dirent *fd;
518 uint32_t alloclen;
519 int ret;
520
521 if (!jffs2_can_mark_obsolete(c)) {
522 /* We can't mark stuff obsolete on the medium. We need to write a deletion dirent */
523
524 rd = jffs2_alloc_raw_dirent();
525 if (!rd)
526 return -ENOMEM;
527
528 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
529 ALLOC_DELETION, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
530 if (ret) {
531 jffs2_free_raw_dirent(rd);
532 return ret;
533 }
534
535 down(&dir_f->sem);
536
537 /* Build a deletion node */
538 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
539 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
540 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
541 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
542
543 rd->pino = cpu_to_je32(dir_f->inocache->ino);
544 rd->version = cpu_to_je32(++dir_f->highest_version);
545 rd->ino = cpu_to_je32(0);
546 rd->mctime = cpu_to_je32(time);
547 rd->nsize = namelen;
548 rd->type = DT_UNKNOWN;
549 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
550 rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
551
552 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_DELETION);
553
554 jffs2_free_raw_dirent(rd);
555
556 if (IS_ERR(fd)) {
557 jffs2_complete_reservation(c);
558 up(&dir_f->sem);
559 return PTR_ERR(fd);
560 }
561
562 /* File it. This will mark the old one obsolete. */
563 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
564 up(&dir_f->sem);
565 } else {
566 struct jffs2_full_dirent **prev = &dir_f->dents;
567 uint32_t nhash = full_name_hash(name, namelen);
568
569 /* We don't actually want to reserve any space, but we do
570 want to be holding the alloc_sem when we write to flash */
571 down(&c->alloc_sem);
572 down(&dir_f->sem);
573
574 while ((*prev) && (*prev)->nhash <= nhash) {
575 if ((*prev)->nhash == nhash &&
576 !memcmp((*prev)->name, name, namelen) &&
577 !(*prev)->name[namelen]) {
578 struct jffs2_full_dirent *this = *prev;
579
580 D1(printk(KERN_DEBUG "Marking old dirent node (ino #%u) @%08x obsolete\n",
581 this->ino, ref_offset(this->raw)));
582
583 *prev = this->next;
584 jffs2_mark_node_obsolete(c, (this->raw));
585 jffs2_free_full_dirent(this);
586 break;
587 }
588 prev = &((*prev)->next);
589 }
590 up(&dir_f->sem);
591 }
592
593 /* dead_f is NULL if this was a rename not a real unlink */
594 /* Also catch the !f->inocache case, where there was a dirent
595 pointing to an inode which didn't exist. */
596 if (dead_f && dead_f->inocache) {
597
598 down(&dead_f->sem);
599
600 if (S_ISDIR(OFNI_EDONI_2SFFJ(dead_f)->i_mode)) {
601 while (dead_f->dents) {
602 /* There can be only deleted ones */
603 fd = dead_f->dents;
604
605 dead_f->dents = fd->next;
606
607 if (fd->ino) {
608 printk(KERN_WARNING "Deleting inode #%u with active dentry \"%s\"->ino #%u\n",
609 dead_f->inocache->ino, fd->name, fd->ino);
610 } else {
611 D1(printk(KERN_DEBUG "Removing deletion dirent for \"%s\" from dir ino #%u\n",
612 fd->name, dead_f->inocache->ino));
613 }
614 jffs2_mark_node_obsolete(c, fd->raw);
615 jffs2_free_full_dirent(fd);
616 }
617 }
618
619 dead_f->inocache->nlink--;
620 /* NB: Caller must set inode nlink if appropriate */
621 up(&dead_f->sem);
622 }
623
624 jffs2_complete_reservation(c);
625
626 return 0;
627 }
628
629
630 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)
631 {
632 struct jffs2_raw_dirent *rd;
633 struct jffs2_full_dirent *fd;
634 uint32_t alloclen;
635 int ret;
636
637 rd = jffs2_alloc_raw_dirent();
638 if (!rd)
639 return -ENOMEM;
640
641 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
642 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
643 if (ret) {
644 jffs2_free_raw_dirent(rd);
645 return ret;
646 }
647
648 down(&dir_f->sem);
649
650 /* Build a deletion node */
651 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
652 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
653 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
654 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
655
656 rd->pino = cpu_to_je32(dir_f->inocache->ino);
657 rd->version = cpu_to_je32(++dir_f->highest_version);
658 rd->ino = cpu_to_je32(ino);
659 rd->mctime = cpu_to_je32(time);
660 rd->nsize = namelen;
661
662 rd->type = type;
663
664 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
665 rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
666
667 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL);
668
669 jffs2_free_raw_dirent(rd);
670
671 if (IS_ERR(fd)) {
672 jffs2_complete_reservation(c);
673 up(&dir_f->sem);
674 return PTR_ERR(fd);
675 }
676
677 /* File it. This will mark the old one obsolete. */
678 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
679
680 jffs2_complete_reservation(c);
681 up(&dir_f->sem);
682
683 return 0;
684 }
Support for the Chinese Samsung S3C2440 based development boards