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