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