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