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