xfs: validate acl count
[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/pagemap.h>
16 #include <linux/mtd/mtd.h>
17 #include "nodelist.h"
18 #include "compr.h"
19
20
21 int jffs2_do_new_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
22                        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->pino_nlink = 1; /* Will be overwritten shortly for directories */
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                                 mutex_unlock(&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                                 mutex_lock(&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                                 mutex_unlock(&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                                 mutex_lock(&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                 mutex_lock(&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                         mutex_unlock(&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                         mutex_unlock(&f->sem);
407                         jffs2_complete_reservation(c);
408                         break;
409                 }
410                 mutex_unlock(&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,
428                     struct jffs2_inode_info *f, struct jffs2_raw_inode *ri,
429                     const struct qstr *qstr)
430 {
431         struct jffs2_raw_dirent *rd;
432         struct jffs2_full_dnode *fn;
433         struct jffs2_full_dirent *fd;
434         uint32_t alloclen;
435         int ret;
436
437         /* Try to reserve enough space for both node and dirent.
438          * Just the node will do for now, though
439          */
440         ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL,
441                                 JFFS2_SUMMARY_INODE_SIZE);
442         D1(printk(KERN_DEBUG "jffs2_do_create(): reserved 0x%x bytes\n", alloclen));
443         if (ret)
444                 return ret;
445
446         mutex_lock(&f->sem);
447
448         ri->data_crc = cpu_to_je32(0);
449         ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
450
451         fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL);
452
453         D1(printk(KERN_DEBUG "jffs2_do_create created file with mode 0x%x\n",
454                   jemode_to_cpu(ri->mode)));
455
456         if (IS_ERR(fn)) {
457                 D1(printk(KERN_DEBUG "jffs2_write_dnode() failed\n"));
458                 /* Eeek. Wave bye bye */
459                 mutex_unlock(&f->sem);
460                 jffs2_complete_reservation(c);
461                 return PTR_ERR(fn);
462         }
463         /* No data here. Only a metadata node, which will be
464            obsoleted by the first data write
465         */
466         f->metadata = fn;
467
468         mutex_unlock(&f->sem);
469         jffs2_complete_reservation(c);
470
471         ret = jffs2_init_security(&f->vfs_inode, &dir_f->vfs_inode, qstr);
472         if (ret)
473                 return ret;
474         ret = jffs2_init_acl_post(&f->vfs_inode);
475         if (ret)
476                 return ret;
477
478         ret = jffs2_reserve_space(c, sizeof(*rd)+qstr->len, &alloclen,
479                                 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(qstr->len));
480
481         if (ret) {
482                 /* Eep. */
483                 D1(printk(KERN_DEBUG "jffs2_reserve_space() for dirent failed\n"));
484                 return ret;
485         }
486
487         rd = jffs2_alloc_raw_dirent();
488         if (!rd) {
489                 /* Argh. Now we treat it like a normal delete */
490                 jffs2_complete_reservation(c);
491                 return -ENOMEM;
492         }
493
494         mutex_lock(&dir_f->sem);
495
496         rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
497         rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
498         rd->totlen = cpu_to_je32(sizeof(*rd) + qstr->len);
499         rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
500
501         rd->pino = cpu_to_je32(dir_f->inocache->ino);
502         rd->version = cpu_to_je32(++dir_f->highest_version);
503         rd->ino = ri->ino;
504         rd->mctime = ri->ctime;
505         rd->nsize = qstr->len;
506         rd->type = DT_REG;
507         rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
508         rd->name_crc = cpu_to_je32(crc32(0, qstr->name, qstr->len));
509
510         fd = jffs2_write_dirent(c, dir_f, rd, qstr->name, qstr->len, ALLOC_NORMAL);
511
512         jffs2_free_raw_dirent(rd);
513
514         if (IS_ERR(fd)) {
515                 /* dirent failed to write. Delete the inode normally
516                    as if it were the final unlink() */
517                 jffs2_complete_reservation(c);
518                 mutex_unlock(&dir_f->sem);
519                 return PTR_ERR(fd);
520         }
521
522         /* Link the fd into the inode's list, obsoleting an old
523            one if necessary. */
524         jffs2_add_fd_to_list(c, fd, &dir_f->dents);
525
526         jffs2_complete_reservation(c);
527         mutex_unlock(&dir_f->sem);
528
529         return 0;
530 }
531
532
533 int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f,
534                     const char *name, int namelen, struct jffs2_inode_info *dead_f,
535                     uint32_t time)
536 {
537         struct jffs2_raw_dirent *rd;
538         struct jffs2_full_dirent *fd;
539         uint32_t alloclen;
540         int ret;
541
542         if (!jffs2_can_mark_obsolete(c)) {
543                 /* We can't mark stuff obsolete on the medium. We need to write a deletion dirent */
544
545                 rd = jffs2_alloc_raw_dirent();
546                 if (!rd)
547                         return -ENOMEM;
548
549                 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
550                                         ALLOC_DELETION, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
551                 if (ret) {
552                         jffs2_free_raw_dirent(rd);
553                         return ret;
554                 }
555
556                 mutex_lock(&dir_f->sem);
557
558                 /* Build a deletion node */
559                 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
560                 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
561                 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
562                 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
563
564                 rd->pino = cpu_to_je32(dir_f->inocache->ino);
565                 rd->version = cpu_to_je32(++dir_f->highest_version);
566                 rd->ino = cpu_to_je32(0);
567                 rd->mctime = cpu_to_je32(time);
568                 rd->nsize = namelen;
569                 rd->type = DT_UNKNOWN;
570                 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
571                 rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
572
573                 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_DELETION);
574
575                 jffs2_free_raw_dirent(rd);
576
577                 if (IS_ERR(fd)) {
578                         jffs2_complete_reservation(c);
579                         mutex_unlock(&dir_f->sem);
580                         return PTR_ERR(fd);
581                 }
582
583                 /* File it. This will mark the old one obsolete. */
584                 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
585                 mutex_unlock(&dir_f->sem);
586         } else {
587                 uint32_t nhash = full_name_hash(name, namelen);
588
589                 fd = dir_f->dents;
590                 /* We don't actually want to reserve any space, but we do
591                    want to be holding the alloc_sem when we write to flash */
592                 mutex_lock(&c->alloc_sem);
593                 mutex_lock(&dir_f->sem);
594
595                 for (fd = dir_f->dents; fd; fd = fd->next) {
596                         if (fd->nhash == nhash &&
597                             !memcmp(fd->name, name, namelen) &&
598                             !fd->name[namelen]) {
599
600                                 D1(printk(KERN_DEBUG "Marking old dirent node (ino #%u) @%08x obsolete\n",
601                                           fd->ino, ref_offset(fd->raw)));
602                                 jffs2_mark_node_obsolete(c, fd->raw);
603                                 /* We don't want to remove it from the list immediately,
604                                    because that screws up getdents()/seek() semantics even
605                                    more than they're screwed already. Turn it into a
606                                    node-less deletion dirent instead -- a placeholder */
607                                 fd->raw = NULL;
608                                 fd->ino = 0;
609                                 break;
610                         }
611                 }
612                 mutex_unlock(&dir_f->sem);
613         }
614
615         /* dead_f is NULL if this was a rename not a real unlink */
616         /* Also catch the !f->inocache case, where there was a dirent
617            pointing to an inode which didn't exist. */
618         if (dead_f && dead_f->inocache) {
619
620                 mutex_lock(&dead_f->sem);
621
622                 if (S_ISDIR(OFNI_EDONI_2SFFJ(dead_f)->i_mode)) {
623                         while (dead_f->dents) {
624                                 /* There can be only deleted ones */
625                                 fd = dead_f->dents;
626
627                                 dead_f->dents = fd->next;
628
629                                 if (fd->ino) {
630                                         printk(KERN_WARNING "Deleting inode #%u with active dentry \"%s\"->ino #%u\n",
631                                                dead_f->inocache->ino, fd->name, fd->ino);
632                                 } else {
633                                         D1(printk(KERN_DEBUG "Removing deletion dirent for \"%s\" from dir ino #%u\n",
634                                                 fd->name, dead_f->inocache->ino));
635                                 }
636                                 if (fd->raw)
637                                         jffs2_mark_node_obsolete(c, fd->raw);
638                                 jffs2_free_full_dirent(fd);
639                         }
640                         dead_f->inocache->pino_nlink = 0;
641                 } else
642                         dead_f->inocache->pino_nlink--;
643                 /* NB: Caller must set inode nlink if appropriate */
644                 mutex_unlock(&dead_f->sem);
645         }
646
647         jffs2_complete_reservation(c);
648
649         return 0;
650 }
651
652
653 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)
654 {
655         struct jffs2_raw_dirent *rd;
656         struct jffs2_full_dirent *fd;
657         uint32_t alloclen;
658         int ret;
659
660         rd = jffs2_alloc_raw_dirent();
661         if (!rd)
662                 return -ENOMEM;
663
664         ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
665                                 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
666         if (ret) {
667                 jffs2_free_raw_dirent(rd);
668                 return ret;
669         }
670
671         mutex_lock(&dir_f->sem);
672
673         /* Build a deletion node */
674         rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
675         rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
676         rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
677         rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
678
679         rd->pino = cpu_to_je32(dir_f->inocache->ino);
680         rd->version = cpu_to_je32(++dir_f->highest_version);
681         rd->ino = cpu_to_je32(ino);
682         rd->mctime = cpu_to_je32(time);
683         rd->nsize = namelen;
684
685         rd->type = type;
686
687         rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
688         rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
689
690         fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL);
691
692         jffs2_free_raw_dirent(rd);
693
694         if (IS_ERR(fd)) {
695                 jffs2_complete_reservation(c);
696                 mutex_unlock(&dir_f->sem);
697                 return PTR_ERR(fd);
698         }
699
700         /* File it. This will mark the old one obsolete. */
701         jffs2_add_fd_to_list(c, fd, &dir_f->dents);
702
703         jffs2_complete_reservation(c);
704         mutex_unlock(&dir_f->sem);
705
706         return 0;
707 }