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

Archive Download this file



interactive