projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/aegl/linux-2.6
[deliverable/linux.git] / fs / jffs2 / write.c
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 if (strnlen(name, namelen) != namelen) {
219 /* This should never happen, but seems to have done on at least one
220 occasion: https://dev.laptop.org/ticket/4184 */
221 printk(KERN_CRIT "Error in jffs2_write_dirent() -- name contains zero bytes!\n");
222 printk(KERN_CRIT "Directory inode #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x\n",
223 je32_to_cpu(rd->pino), name, name, je32_to_cpu(rd->ino),
224 je32_to_cpu(rd->name_crc));
225 WARN_ON(1);
226 return ERR_PTR(-EIO);
227 }
228
229 vecs[0].iov_base = rd;
230 vecs[0].iov_len = sizeof(*rd);
231 vecs[1].iov_base = (unsigned char *)name;
232 vecs[1].iov_len = namelen;
233
234 fd = jffs2_alloc_full_dirent(namelen+1);
235 if (!fd)
236 return ERR_PTR(-ENOMEM);
237
238 fd->version = je32_to_cpu(rd->version);
239 fd->ino = je32_to_cpu(rd->ino);
240 fd->nhash = full_name_hash(name, namelen);
241 fd->type = rd->type;
242 memcpy(fd->name, name, namelen);
243 fd->name[namelen]=0;
244
245 retry:
246 flash_ofs = write_ofs(c);
247
248 jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len);
249
250 if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(rd->version) < f->highest_version)) {
251 BUG_ON(!retried);
252 D1(printk(KERN_DEBUG "jffs2_write_dirent : dirent_version %d, "
253 "highest version %d -> updating dirent\n",
254 je32_to_cpu(rd->version), f->highest_version));
255 rd->version = cpu_to_je32(++f->highest_version);
256 fd->version = je32_to_cpu(rd->version);
257 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
258 }
259
260 ret = jffs2_flash_writev(c, vecs, 2, flash_ofs, &retlen,
261 (alloc_mode==ALLOC_GC)?0:je32_to_cpu(rd->pino));
262 if (ret || (retlen != sizeof(*rd) + namelen)) {
263 printk(KERN_NOTICE "Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
264 sizeof(*rd)+namelen, flash_ofs, ret, retlen);
265 /* Mark the space as dirtied */
266 if (retlen) {
267 jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*rd)+namelen), NULL);
268 } else {
269 printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", flash_ofs);
270 }
271 if (!retried) {
272 /* Try to reallocate space and retry */
273 uint32_t dummy;
274 struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
275
276 retried = 1;
277
278 D1(printk(KERN_DEBUG "Retrying failed write.\n"));
279
280 jffs2_dbg_acct_sanity_check(c,jeb);
281 jffs2_dbg_acct_paranoia_check(c, jeb);
282
283 if (alloc_mode == ALLOC_GC) {
284 ret = jffs2_reserve_space_gc(c, sizeof(*rd) + namelen, &dummy,
285 JFFS2_SUMMARY_DIRENT_SIZE(namelen));
286 } else {
287 /* Locking pain */
288 up(&f->sem);
289 jffs2_complete_reservation(c);
290
291 ret = jffs2_reserve_space(c, sizeof(*rd) + namelen, &dummy,
292 alloc_mode, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
293 down(&f->sem);
294 }
295
296 if (!ret) {
297 flash_ofs = write_ofs(c);
298 D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs));
299 jffs2_dbg_acct_sanity_check(c,jeb);
300 jffs2_dbg_acct_paranoia_check(c, jeb);
301 goto retry;
302 }
303 D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret));
304 }
305 /* Release the full_dnode which is now useless, and return */
306 jffs2_free_full_dirent(fd);
307 return ERR_PTR(ret?ret:-EIO);
308 }
309 /* Mark the space used */
310 fd->raw = jffs2_add_physical_node_ref(c, flash_ofs | dirent_node_state(rd),
311 PAD(sizeof(*rd)+namelen), f->inocache);
312 if (IS_ERR(fd->raw)) {
313 void *hold_err = fd->raw;
314 /* Release the full_dirent which is now useless, and return */
315 jffs2_free_full_dirent(fd);
316 return ERR_PTR(PTR_ERR(hold_err));
317 }
318
319 if (retried) {
320 jffs2_dbg_acct_sanity_check(c,NULL);
321 }
322
323 return fd;
324 }
325
326 /* The OS-specific code fills in the metadata in the jffs2_raw_inode for us, so that
327 we don't have to go digging in struct inode or its equivalent. It should set:
328 mode, uid, gid, (starting)isize, atime, ctime, mtime */
329 int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
330 struct jffs2_raw_inode *ri, unsigned char *buf,
331 uint32_t offset, uint32_t writelen, uint32_t *retlen)
332 {
333 int ret = 0;
334 uint32_t writtenlen = 0;
335
336 D1(printk(KERN_DEBUG "jffs2_write_inode_range(): Ino #%u, ofs 0x%x, len 0x%x\n",
337 f->inocache->ino, offset, writelen));
338
339 while(writelen) {
340 struct jffs2_full_dnode *fn;
341 unsigned char *comprbuf = NULL;
342 uint16_t comprtype = JFFS2_COMPR_NONE;
343 uint32_t alloclen;
344 uint32_t datalen, cdatalen;
345 int retried = 0;
346
347 retry:
348 D2(printk(KERN_DEBUG "jffs2_commit_write() loop: 0x%x to write to 0x%x\n", writelen, offset));
349
350 ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN,
351 &alloclen, ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
352 if (ret) {
353 D1(printk(KERN_DEBUG "jffs2_reserve_space returned %d\n", ret));
354 break;
355 }
356 down(&f->sem);
357 datalen = min_t(uint32_t, writelen, PAGE_CACHE_SIZE - (offset & (PAGE_CACHE_SIZE-1)));
358 cdatalen = min_t(uint32_t, alloclen - sizeof(*ri), datalen);
359
360 comprtype = jffs2_compress(c, f, buf, &comprbuf, &datalen, &cdatalen);
361
362 ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
363 ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
364 ri->totlen = cpu_to_je32(sizeof(*ri) + cdatalen);
365 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
366
367 ri->ino = cpu_to_je32(f->inocache->ino);
368 ri->version = cpu_to_je32(++f->highest_version);
369 ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen));
370 ri->offset = cpu_to_je32(offset);
371 ri->csize = cpu_to_je32(cdatalen);
372 ri->dsize = cpu_to_je32(datalen);
373 ri->compr = comprtype & 0xff;
374 ri->usercompr = (comprtype >> 8 ) & 0xff;
375 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
376 ri->data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
377
378 fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, ALLOC_NORETRY);
379
380 jffs2_free_comprbuf(comprbuf, buf);
381
382 if (IS_ERR(fn)) {
383 ret = PTR_ERR(fn);
384 up(&f->sem);
385 jffs2_complete_reservation(c);
386 if (!retried) {
387 /* Write error to be retried */
388 retried = 1;
389 D1(printk(KERN_DEBUG "Retrying node write in jffs2_write_inode_range()\n"));
390 goto retry;
391 }
392 break;
393 }
394 ret = jffs2_add_full_dnode_to_inode(c, f, fn);
395 if (f->metadata) {
396 jffs2_mark_node_obsolete(c, f->metadata->raw);
397 jffs2_free_full_dnode(f->metadata);
398 f->metadata = NULL;
399 }
400 if (ret) {
401 /* Eep */
402 D1(printk(KERN_DEBUG "Eep. add_full_dnode_to_inode() failed in commit_write, returned %d\n", ret));
403 jffs2_mark_node_obsolete(c, fn->raw);
404 jffs2_free_full_dnode(fn);
405
406 up(&f->sem);
407 jffs2_complete_reservation(c);
408 break;
409 }
410 up(&f->sem);
411 jffs2_complete_reservation(c);
412 if (!datalen) {
413 printk(KERN_WARNING "Eep. We didn't actually write any data in jffs2_write_inode_range()\n");
414 ret = -EIO;
415 break;
416 }
417 D1(printk(KERN_DEBUG "increasing writtenlen by %d\n", datalen));
418 writtenlen += datalen;
419 offset += datalen;
420 writelen -= datalen;
421 buf += datalen;
422 }
423 *retlen = writtenlen;
424 return ret;
425 }
426
427 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)
428 {
429 struct jffs2_raw_dirent *rd;
430 struct jffs2_full_dnode *fn;
431 struct jffs2_full_dirent *fd;
432 uint32_t alloclen;
433 int ret;
434
435 /* Try to reserve enough space for both node and dirent.
436 * Just the node will do for now, though
437 */
438 ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL,
439 JFFS2_SUMMARY_INODE_SIZE);
440 D1(printk(KERN_DEBUG "jffs2_do_create(): reserved 0x%x bytes\n", alloclen));
441 if (ret) {
442 up(&f->sem);
443 return ret;
444 }
445
446 ri->data_crc = cpu_to_je32(0);
447 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
448
449 fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL);
450
451 D1(printk(KERN_DEBUG "jffs2_do_create created file with mode 0x%x\n",
452 jemode_to_cpu(ri->mode)));
453
454 if (IS_ERR(fn)) {
455 D1(printk(KERN_DEBUG "jffs2_write_dnode() failed\n"));
456 /* Eeek. Wave bye bye */
457 up(&f->sem);
458 jffs2_complete_reservation(c);
459 return PTR_ERR(fn);
460 }
461 /* No data here. Only a metadata node, which will be
462 obsoleted by the first data write
463 */
464 f->metadata = fn;
465
466 up(&f->sem);
467 jffs2_complete_reservation(c);
468 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
469 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
470
471 if (ret) {
472 /* Eep. */
473 D1(printk(KERN_DEBUG "jffs2_reserve_space() for dirent failed\n"));
474 return ret;
475 }
476
477 rd = jffs2_alloc_raw_dirent();
478 if (!rd) {
479 /* Argh. Now we treat it like a normal delete */
480 jffs2_complete_reservation(c);
481 return -ENOMEM;
482 }
483
484 down(&dir_f->sem);
485
486 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
487 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
488 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
489 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
490
491 rd->pino = cpu_to_je32(dir_f->inocache->ino);
492 rd->version = cpu_to_je32(++dir_f->highest_version);
493 rd->ino = ri->ino;
494 rd->mctime = ri->ctime;
495 rd->nsize = namelen;
496 rd->type = DT_REG;
497 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
498 rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
499
500 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL);
501
502 jffs2_free_raw_dirent(rd);
503
504 if (IS_ERR(fd)) {
505 /* dirent failed to write. Delete the inode normally
506 as if it were the final unlink() */
507 jffs2_complete_reservation(c);
508 up(&dir_f->sem);
509 return PTR_ERR(fd);
510 }
511
512 /* Link the fd into the inode's list, obsoleting an old
513 one if necessary. */
514 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
515
516 jffs2_complete_reservation(c);
517 up(&dir_f->sem);
518
519 return 0;
520 }
521
522
523 int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f,
524 const char *name, int namelen, struct jffs2_inode_info *dead_f,
525 uint32_t time)
526 {
527 struct jffs2_raw_dirent *rd;
528 struct jffs2_full_dirent *fd;
529 uint32_t alloclen;
530 int ret;
531
532 if (!jffs2_can_mark_obsolete(c)) {
533 /* We can't mark stuff obsolete on the medium. We need to write a deletion dirent */
534
535 rd = jffs2_alloc_raw_dirent();
536 if (!rd)
537 return -ENOMEM;
538
539 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
540 ALLOC_DELETION, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
541 if (ret) {
542 jffs2_free_raw_dirent(rd);
543 return ret;
544 }
545
546 down(&dir_f->sem);
547
548 /* Build a deletion node */
549 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
550 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
551 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
552 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
553
554 rd->pino = cpu_to_je32(dir_f->inocache->ino);
555 rd->version = cpu_to_je32(++dir_f->highest_version);
556 rd->ino = cpu_to_je32(0);
557 rd->mctime = cpu_to_je32(time);
558 rd->nsize = namelen;
559 rd->type = DT_UNKNOWN;
560 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
561 rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
562
563 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_DELETION);
564
565 jffs2_free_raw_dirent(rd);
566
567 if (IS_ERR(fd)) {
568 jffs2_complete_reservation(c);
569 up(&dir_f->sem);
570 return PTR_ERR(fd);
571 }
572
573 /* File it. This will mark the old one obsolete. */
574 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
575 up(&dir_f->sem);
576 } else {
577 struct jffs2_full_dirent **prev = &dir_f->dents;
578 uint32_t nhash = full_name_hash(name, namelen);
579
580 /* We don't actually want to reserve any space, but we do
581 want to be holding the alloc_sem when we write to flash */
582 down(&c->alloc_sem);
583 down(&dir_f->sem);
584
585 while ((*prev) && (*prev)->nhash <= nhash) {
586 if ((*prev)->nhash == nhash &&
587 !memcmp((*prev)->name, name, namelen) &&
588 !(*prev)->name[namelen]) {
589 struct jffs2_full_dirent *this = *prev;
590
591 D1(printk(KERN_DEBUG "Marking old dirent node (ino #%u) @%08x obsolete\n",
592 this->ino, ref_offset(this->raw)));
593
594 *prev = this->next;
595 jffs2_mark_node_obsolete(c, (this->raw));
596 jffs2_free_full_dirent(this);
597 break;
598 }
599 prev = &((*prev)->next);
600 }
601 up(&dir_f->sem);
602 }
603
604 /* dead_f is NULL if this was a rename not a real unlink */
605 /* Also catch the !f->inocache case, where there was a dirent
606 pointing to an inode which didn't exist. */
607 if (dead_f && dead_f->inocache) {
608
609 down(&dead_f->sem);
610
611 if (S_ISDIR(OFNI_EDONI_2SFFJ(dead_f)->i_mode)) {
612 while (dead_f->dents) {
613 /* There can be only deleted ones */
614 fd = dead_f->dents;
615
616 dead_f->dents = fd->next;
617
618 if (fd->ino) {
619 printk(KERN_WARNING "Deleting inode #%u with active dentry \"%s\"->ino #%u\n",
620 dead_f->inocache->ino, fd->name, fd->ino);
621 } else {
622 D1(printk(KERN_DEBUG "Removing deletion dirent for \"%s\" from dir ino #%u\n",
623 fd->name, dead_f->inocache->ino));
624 }
625 jffs2_mark_node_obsolete(c, fd->raw);
626 jffs2_free_full_dirent(fd);
627 }
628 }
629
630 dead_f->inocache->nlink--;
631 /* NB: Caller must set inode nlink if appropriate */
632 up(&dead_f->sem);
633 }
634
635 jffs2_complete_reservation(c);
636
637 return 0;
638 }
639
640
641 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)
642 {
643 struct jffs2_raw_dirent *rd;
644 struct jffs2_full_dirent *fd;
645 uint32_t alloclen;
646 int ret;
647
648 rd = jffs2_alloc_raw_dirent();
649 if (!rd)
650 return -ENOMEM;
651
652 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
653 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
654 if (ret) {
655 jffs2_free_raw_dirent(rd);
656 return ret;
657 }
658
659 down(&dir_f->sem);
660
661 /* Build a deletion node */
662 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
663 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
664 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
665 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
666
667 rd->pino = cpu_to_je32(dir_f->inocache->ino);
668 rd->version = cpu_to_je32(++dir_f->highest_version);
669 rd->ino = cpu_to_je32(ino);
670 rd->mctime = cpu_to_je32(time);
671 rd->nsize = namelen;
672
673 rd->type = type;
674
675 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
676 rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
677
678 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL);
679
680 jffs2_free_raw_dirent(rd);
681
682 if (IS_ERR(fd)) {
683 jffs2_complete_reservation(c);
684 up(&dir_f->sem);
685 return PTR_ERR(fd);
686 }
687
688 /* File it. This will mark the old one obsolete. */
689 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
690
691 jffs2_complete_reservation(c);
692 up(&dir_f->sem);
693
694 return 0;
695 }
Linux kernel - Deliverables
This page took 0.107952 seconds and 5 git commands to generate.