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