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