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