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