11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * JFFS2 -- Journalling Flash File System, Version 2. 31da177e4SLinus Torvalds * 4c00c310eSDavid Woodhouse * Copyright © 2001-2007 Red Hat, Inc. 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * Created by David Woodhouse <dwmw2@infradead.org> 71da177e4SLinus Torvalds * 81da177e4SLinus Torvalds * For licensing information, see the file 'LICENCE' in this directory. 91da177e4SLinus Torvalds * 101da177e4SLinus Torvalds */ 111da177e4SLinus Torvalds 121da177e4SLinus Torvalds #include <linux/kernel.h> 131da177e4SLinus Torvalds #include <linux/fs.h> 141da177e4SLinus Torvalds #include <linux/crc32.h> 151da177e4SLinus Torvalds #include <linux/pagemap.h> 161da177e4SLinus Torvalds #include <linux/mtd/mtd.h> 171da177e4SLinus Torvalds #include "nodelist.h" 181da177e4SLinus Torvalds #include "compr.h" 191da177e4SLinus Torvalds 201da177e4SLinus Torvalds 2127c72b04SDavid Woodhouse int jffs2_do_new_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 2227c72b04SDavid Woodhouse uint32_t mode, struct jffs2_raw_inode *ri) 231da177e4SLinus Torvalds { 241da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 251da177e4SLinus Torvalds 261da177e4SLinus Torvalds ic = jffs2_alloc_inode_cache(); 271da177e4SLinus Torvalds if (!ic) { 281da177e4SLinus Torvalds return -ENOMEM; 291da177e4SLinus Torvalds } 301da177e4SLinus Torvalds 311da177e4SLinus Torvalds memset(ic, 0, sizeof(*ic)); 321da177e4SLinus Torvalds 331da177e4SLinus Torvalds f->inocache = ic; 3427c72b04SDavid Woodhouse f->inocache->pino_nlink = 1; /* Will be overwritten shortly for directories */ 351da177e4SLinus Torvalds f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache; 361da177e4SLinus Torvalds f->inocache->state = INO_STATE_PRESENT; 371da177e4SLinus Torvalds 381da177e4SLinus Torvalds jffs2_add_ino_cache(c, f->inocache); 399c261b33SJoe Perches jffs2_dbg(1, "%s(): Assigned ino# %d\n", __func__, f->inocache->ino); 407d200960SDavid Woodhouse ri->ino = cpu_to_je32(f->inocache->ino); 411da177e4SLinus Torvalds 421da177e4SLinus Torvalds ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 431da177e4SLinus Torvalds ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE); 441da177e4SLinus Torvalds ri->totlen = cpu_to_je32(PAD(sizeof(*ri))); 451da177e4SLinus Torvalds ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 461da177e4SLinus Torvalds ri->mode = cpu_to_jemode(mode); 471da177e4SLinus Torvalds 481da177e4SLinus Torvalds f->highest_version = 1; 491da177e4SLinus Torvalds ri->version = cpu_to_je32(f->highest_version); 501da177e4SLinus Torvalds 511da177e4SLinus Torvalds return 0; 521da177e4SLinus Torvalds } 531da177e4SLinus Torvalds 541da177e4SLinus Torvalds /* jffs2_write_dnode - given a raw_inode, allocate a full_dnode for it, 551da177e4SLinus Torvalds write it to the flash, link it into the existing inode/fragment list */ 561da177e4SLinus Torvalds 579fe4854cSDavid Woodhouse struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 589fe4854cSDavid Woodhouse struct jffs2_raw_inode *ri, const unsigned char *data, 599fe4854cSDavid Woodhouse uint32_t datalen, int alloc_mode) 601da177e4SLinus Torvalds 611da177e4SLinus Torvalds { 621da177e4SLinus Torvalds struct jffs2_full_dnode *fn; 631da177e4SLinus Torvalds size_t retlen; 649fe4854cSDavid Woodhouse uint32_t flash_ofs; 651da177e4SLinus Torvalds struct kvec vecs[2]; 661da177e4SLinus Torvalds int ret; 671da177e4SLinus Torvalds int retried = 0; 681da177e4SLinus Torvalds unsigned long cnt = 2; 691da177e4SLinus Torvalds 701da177e4SLinus Torvalds D1(if(je32_to_cpu(ri->hdr_crc) != crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)) { 71da320f05SJoe Perches pr_crit("Eep. CRC not correct in jffs2_write_dnode()\n"); 721da177e4SLinus Torvalds BUG(); 731da177e4SLinus Torvalds } 741da177e4SLinus Torvalds ); 751da177e4SLinus Torvalds vecs[0].iov_base = ri; 761da177e4SLinus Torvalds vecs[0].iov_len = sizeof(*ri); 771da177e4SLinus Torvalds vecs[1].iov_base = (unsigned char *)data; 781da177e4SLinus Torvalds vecs[1].iov_len = datalen; 791da177e4SLinus Torvalds 801da177e4SLinus Torvalds if (je32_to_cpu(ri->totlen) != sizeof(*ri) + datalen) { 81da320f05SJoe Perches pr_warn("%s(): ri->totlen (0x%08x) != sizeof(*ri) (0x%08zx) + datalen (0x%08x)\n", 82da320f05SJoe Perches __func__, je32_to_cpu(ri->totlen), 83da320f05SJoe Perches sizeof(*ri), datalen); 841da177e4SLinus Torvalds } 851da177e4SLinus Torvalds 861da177e4SLinus Torvalds fn = jffs2_alloc_full_dnode(); 872f785402SDavid Woodhouse if (!fn) 881da177e4SLinus Torvalds return ERR_PTR(-ENOMEM); 891da177e4SLinus Torvalds 901da177e4SLinus Torvalds /* check number of valid vecs */ 911da177e4SLinus Torvalds if (!datalen || !data) 921da177e4SLinus Torvalds cnt = 1; 931da177e4SLinus Torvalds retry: 942f785402SDavid Woodhouse flash_ofs = write_ofs(c); 959fe4854cSDavid Woodhouse 969fe4854cSDavid Woodhouse jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len); 971da177e4SLinus Torvalds 989b88f473SEstelle Hammache if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(ri->version) < f->highest_version)) { 999b88f473SEstelle Hammache BUG_ON(!retried); 1009c261b33SJoe Perches jffs2_dbg(1, "%s(): dnode_version %d, highest version %d -> updating dnode\n", 1019c261b33SJoe Perches __func__, 1029c261b33SJoe Perches je32_to_cpu(ri->version), f->highest_version); 103e4803c30SEstelle Hammache ri->version = cpu_to_je32(++f->highest_version); 104e4803c30SEstelle Hammache ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 105e4803c30SEstelle Hammache } 106e4803c30SEstelle Hammache 1071da177e4SLinus Torvalds ret = jffs2_flash_writev(c, vecs, cnt, flash_ofs, &retlen, 1081da177e4SLinus Torvalds (alloc_mode==ALLOC_GC)?0:f->inocache->ino); 1091da177e4SLinus Torvalds 1101da177e4SLinus Torvalds if (ret || (retlen != sizeof(*ri) + datalen)) { 111da320f05SJoe Perches pr_notice("Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n", 1121da177e4SLinus Torvalds sizeof(*ri) + datalen, flash_ofs, ret, retlen); 1131da177e4SLinus Torvalds 1141da177e4SLinus Torvalds /* Mark the space as dirtied */ 1151da177e4SLinus Torvalds if (retlen) { 1161da177e4SLinus Torvalds /* Don't change raw->size to match retlen. We may have 1171da177e4SLinus Torvalds written the node header already, and only the data will 1181da177e4SLinus Torvalds seem corrupted, in which case the scan would skip over 1191da177e4SLinus Torvalds any node we write before the original intended end of 1201da177e4SLinus Torvalds this node */ 1212f785402SDavid Woodhouse jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*ri)+datalen), NULL); 1221da177e4SLinus Torvalds } else { 123da320f05SJoe Perches pr_notice("Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", 124da320f05SJoe Perches flash_ofs); 1251da177e4SLinus Torvalds } 1262f785402SDavid Woodhouse if (!retried && alloc_mode != ALLOC_NORETRY) { 1271da177e4SLinus Torvalds /* Try to reallocate space and retry */ 1281da177e4SLinus Torvalds uint32_t dummy; 1291da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size]; 1301da177e4SLinus Torvalds 1311da177e4SLinus Torvalds retried = 1; 1321da177e4SLinus Torvalds 1339c261b33SJoe Perches jffs2_dbg(1, "Retrying failed write.\n"); 1341da177e4SLinus Torvalds 135730554d9SArtem B. Bityutskiy jffs2_dbg_acct_sanity_check(c,jeb); 136730554d9SArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check(c, jeb); 1371da177e4SLinus Torvalds 1381da177e4SLinus Torvalds if (alloc_mode == ALLOC_GC) { 1399fe4854cSDavid Woodhouse ret = jffs2_reserve_space_gc(c, sizeof(*ri) + datalen, &dummy, 1409fe4854cSDavid Woodhouse JFFS2_SUMMARY_INODE_SIZE); 1411da177e4SLinus Torvalds } else { 1421da177e4SLinus Torvalds /* Locking pain */ 143ced22070SDavid Woodhouse mutex_unlock(&f->sem); 1441da177e4SLinus Torvalds jffs2_complete_reservation(c); 1451da177e4SLinus Torvalds 1469fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*ri) + datalen, &dummy, 1479fe4854cSDavid Woodhouse alloc_mode, JFFS2_SUMMARY_INODE_SIZE); 148ced22070SDavid Woodhouse mutex_lock(&f->sem); 1491da177e4SLinus Torvalds } 1501da177e4SLinus Torvalds 1511da177e4SLinus Torvalds if (!ret) { 1529fe4854cSDavid Woodhouse flash_ofs = write_ofs(c); 1539c261b33SJoe Perches jffs2_dbg(1, "Allocated space at 0x%08x to retry failed write.\n", 1549c261b33SJoe Perches flash_ofs); 1551da177e4SLinus Torvalds 156730554d9SArtem B. Bityutskiy jffs2_dbg_acct_sanity_check(c,jeb); 157730554d9SArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check(c, jeb); 1581da177e4SLinus Torvalds 1591da177e4SLinus Torvalds goto retry; 1601da177e4SLinus Torvalds } 1619c261b33SJoe Perches jffs2_dbg(1, "Failed to allocate space to retry failed write: %d!\n", 1629c261b33SJoe Perches ret); 1631da177e4SLinus Torvalds } 1641da177e4SLinus Torvalds /* Release the full_dnode which is now useless, and return */ 1651da177e4SLinus Torvalds jffs2_free_full_dnode(fn); 1661da177e4SLinus Torvalds return ERR_PTR(ret?ret:-EIO); 1671da177e4SLinus Torvalds } 1681da177e4SLinus Torvalds /* Mark the space used */ 1691da177e4SLinus Torvalds /* If node covers at least a whole page, or if it starts at the 1701da177e4SLinus Torvalds beginning of a page and runs to the end of the file, or if 1711da177e4SLinus Torvalds it's a hole node, mark it REF_PRISTINE, else REF_NORMAL. 1721da177e4SLinus Torvalds */ 1731da177e4SLinus Torvalds if ((je32_to_cpu(ri->dsize) >= PAGE_CACHE_SIZE) || 1741da177e4SLinus Torvalds ( ((je32_to_cpu(ri->offset)&(PAGE_CACHE_SIZE-1))==0) && 1751da177e4SLinus Torvalds (je32_to_cpu(ri->dsize)+je32_to_cpu(ri->offset) == je32_to_cpu(ri->isize)))) { 1762f785402SDavid Woodhouse flash_ofs |= REF_PRISTINE; 1771da177e4SLinus Torvalds } else { 1782f785402SDavid Woodhouse flash_ofs |= REF_NORMAL; 1791da177e4SLinus Torvalds } 1802f785402SDavid Woodhouse fn->raw = jffs2_add_physical_node_ref(c, flash_ofs, PAD(sizeof(*ri)+datalen), f->inocache); 1815bd5c03cSJoakim Tjernlund if (IS_ERR(fn->raw)) { 1825bd5c03cSJoakim Tjernlund void *hold_err = fn->raw; 1835bd5c03cSJoakim Tjernlund /* Release the full_dnode which is now useless, and return */ 1845bd5c03cSJoakim Tjernlund jffs2_free_full_dnode(fn); 185e231c2eeSDavid Howells return ERR_CAST(hold_err); 1865bd5c03cSJoakim Tjernlund } 1872f785402SDavid Woodhouse fn->ofs = je32_to_cpu(ri->offset); 1882f785402SDavid Woodhouse fn->size = je32_to_cpu(ri->dsize); 1892f785402SDavid Woodhouse fn->frags = 0; 1901da177e4SLinus Torvalds 1919c261b33SJoe Perches 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", 1922f785402SDavid Woodhouse flash_ofs & ~3, flash_ofs & 3, je32_to_cpu(ri->dsize), 1931da177e4SLinus Torvalds je32_to_cpu(ri->csize), je32_to_cpu(ri->node_crc), 1949c261b33SJoe Perches je32_to_cpu(ri->data_crc), je32_to_cpu(ri->totlen)); 1951da177e4SLinus Torvalds 1961da177e4SLinus Torvalds if (retried) { 197730554d9SArtem B. Bityutskiy jffs2_dbg_acct_sanity_check(c,NULL); 1981da177e4SLinus Torvalds } 1991da177e4SLinus Torvalds 2001da177e4SLinus Torvalds return fn; 2011da177e4SLinus Torvalds } 2021da177e4SLinus Torvalds 2039fe4854cSDavid Woodhouse struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 2049fe4854cSDavid Woodhouse struct jffs2_raw_dirent *rd, const unsigned char *name, 2059fe4854cSDavid Woodhouse uint32_t namelen, int alloc_mode) 2061da177e4SLinus Torvalds { 2071da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 2081da177e4SLinus Torvalds size_t retlen; 2091da177e4SLinus Torvalds struct kvec vecs[2]; 2102f785402SDavid Woodhouse uint32_t flash_ofs; 2111da177e4SLinus Torvalds int retried = 0; 2121da177e4SLinus Torvalds int ret; 2131da177e4SLinus Torvalds 2149c261b33SJoe Perches jffs2_dbg(1, "%s(ino #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x)\n", 2159c261b33SJoe Perches __func__, 2161da177e4SLinus Torvalds je32_to_cpu(rd->pino), name, name, je32_to_cpu(rd->ino), 2179c261b33SJoe Perches je32_to_cpu(rd->name_crc)); 218730554d9SArtem B. Bityutskiy 2191da177e4SLinus Torvalds D1(if(je32_to_cpu(rd->hdr_crc) != crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)) { 220da320f05SJoe Perches pr_crit("Eep. CRC not correct in jffs2_write_dirent()\n"); 2211da177e4SLinus Torvalds BUG(); 2222f785402SDavid Woodhouse }); 2231da177e4SLinus Torvalds 22469ca4378SDavid Woodhouse if (strnlen(name, namelen) != namelen) { 22569ca4378SDavid Woodhouse /* This should never happen, but seems to have done on at least one 22669ca4378SDavid Woodhouse occasion: https://dev.laptop.org/ticket/4184 */ 227da320f05SJoe Perches pr_crit("Error in jffs2_write_dirent() -- name contains zero bytes!\n"); 228da320f05SJoe Perches pr_crit("Directory inode #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x\n", 22969ca4378SDavid Woodhouse je32_to_cpu(rd->pino), name, name, je32_to_cpu(rd->ino), 23069ca4378SDavid Woodhouse je32_to_cpu(rd->name_crc)); 23169ca4378SDavid Woodhouse WARN_ON(1); 23269ca4378SDavid Woodhouse return ERR_PTR(-EIO); 23369ca4378SDavid Woodhouse } 23469ca4378SDavid Woodhouse 2351da177e4SLinus Torvalds vecs[0].iov_base = rd; 2361da177e4SLinus Torvalds vecs[0].iov_len = sizeof(*rd); 2371da177e4SLinus Torvalds vecs[1].iov_base = (unsigned char *)name; 2381da177e4SLinus Torvalds vecs[1].iov_len = namelen; 2391da177e4SLinus Torvalds 2401da177e4SLinus Torvalds fd = jffs2_alloc_full_dirent(namelen+1); 2412f785402SDavid Woodhouse if (!fd) 2421da177e4SLinus Torvalds return ERR_PTR(-ENOMEM); 2431da177e4SLinus Torvalds 2441da177e4SLinus Torvalds fd->version = je32_to_cpu(rd->version); 2451da177e4SLinus Torvalds fd->ino = je32_to_cpu(rd->ino); 24669ca4378SDavid Woodhouse fd->nhash = full_name_hash(name, namelen); 2471da177e4SLinus Torvalds fd->type = rd->type; 2481da177e4SLinus Torvalds memcpy(fd->name, name, namelen); 2491da177e4SLinus Torvalds fd->name[namelen]=0; 2501da177e4SLinus Torvalds 2511da177e4SLinus Torvalds retry: 2522f785402SDavid Woodhouse flash_ofs = write_ofs(c); 2531da177e4SLinus Torvalds 2542f785402SDavid Woodhouse jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len); 2551da177e4SLinus Torvalds 2569b88f473SEstelle Hammache if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(rd->version) < f->highest_version)) { 2579b88f473SEstelle Hammache BUG_ON(!retried); 2589c261b33SJoe Perches jffs2_dbg(1, "%s(): dirent_version %d, highest version %d -> updating dirent\n", 2599c261b33SJoe Perches __func__, 2609c261b33SJoe Perches je32_to_cpu(rd->version), f->highest_version); 261e4803c30SEstelle Hammache rd->version = cpu_to_je32(++f->highest_version); 262e4803c30SEstelle Hammache fd->version = je32_to_cpu(rd->version); 263e4803c30SEstelle Hammache rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 264e4803c30SEstelle Hammache } 265e4803c30SEstelle Hammache 2661da177e4SLinus Torvalds ret = jffs2_flash_writev(c, vecs, 2, flash_ofs, &retlen, 2671da177e4SLinus Torvalds (alloc_mode==ALLOC_GC)?0:je32_to_cpu(rd->pino)); 2681da177e4SLinus Torvalds if (ret || (retlen != sizeof(*rd) + namelen)) { 269da320f05SJoe Perches pr_notice("Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n", 2701da177e4SLinus Torvalds sizeof(*rd) + namelen, flash_ofs, ret, retlen); 2711da177e4SLinus Torvalds /* Mark the space as dirtied */ 2721da177e4SLinus Torvalds if (retlen) { 2732f785402SDavid Woodhouse jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*rd)+namelen), NULL); 2741da177e4SLinus Torvalds } else { 275da320f05SJoe Perches pr_notice("Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", 276da320f05SJoe Perches flash_ofs); 2771da177e4SLinus Torvalds } 2782f785402SDavid Woodhouse if (!retried) { 2791da177e4SLinus Torvalds /* Try to reallocate space and retry */ 2801da177e4SLinus Torvalds uint32_t dummy; 2811da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size]; 2821da177e4SLinus Torvalds 2831da177e4SLinus Torvalds retried = 1; 2841da177e4SLinus Torvalds 2859c261b33SJoe Perches jffs2_dbg(1, "Retrying failed write.\n"); 2861da177e4SLinus Torvalds 287730554d9SArtem B. Bityutskiy jffs2_dbg_acct_sanity_check(c,jeb); 288730554d9SArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check(c, jeb); 2891da177e4SLinus Torvalds 2901da177e4SLinus Torvalds if (alloc_mode == ALLOC_GC) { 2919fe4854cSDavid Woodhouse ret = jffs2_reserve_space_gc(c, sizeof(*rd) + namelen, &dummy, 2929fe4854cSDavid Woodhouse JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 2931da177e4SLinus Torvalds } else { 2941da177e4SLinus Torvalds /* Locking pain */ 295ced22070SDavid Woodhouse mutex_unlock(&f->sem); 2961da177e4SLinus Torvalds jffs2_complete_reservation(c); 2971da177e4SLinus Torvalds 2989fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*rd) + namelen, &dummy, 2999fe4854cSDavid Woodhouse alloc_mode, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 300ced22070SDavid Woodhouse mutex_lock(&f->sem); 3011da177e4SLinus Torvalds } 3021da177e4SLinus Torvalds 3031da177e4SLinus Torvalds if (!ret) { 3049fe4854cSDavid Woodhouse flash_ofs = write_ofs(c); 3059c261b33SJoe Perches jffs2_dbg(1, "Allocated space at 0x%08x to retry failed write\n", 3069c261b33SJoe Perches flash_ofs); 307730554d9SArtem B. Bityutskiy jffs2_dbg_acct_sanity_check(c,jeb); 308730554d9SArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check(c, jeb); 3091da177e4SLinus Torvalds goto retry; 3101da177e4SLinus Torvalds } 3119c261b33SJoe Perches jffs2_dbg(1, "Failed to allocate space to retry failed write: %d!\n", 3129c261b33SJoe Perches ret); 3131da177e4SLinus Torvalds } 3141da177e4SLinus Torvalds /* Release the full_dnode which is now useless, and return */ 3151da177e4SLinus Torvalds jffs2_free_full_dirent(fd); 3161da177e4SLinus Torvalds return ERR_PTR(ret?ret:-EIO); 3171da177e4SLinus Torvalds } 3181da177e4SLinus Torvalds /* Mark the space used */ 31971c23397SDavid Woodhouse fd->raw = jffs2_add_physical_node_ref(c, flash_ofs | dirent_node_state(rd), 32071c23397SDavid Woodhouse PAD(sizeof(*rd)+namelen), f->inocache); 3215bd5c03cSJoakim Tjernlund if (IS_ERR(fd->raw)) { 3225bd5c03cSJoakim Tjernlund void *hold_err = fd->raw; 3235bd5c03cSJoakim Tjernlund /* Release the full_dirent which is now useless, and return */ 3245bd5c03cSJoakim Tjernlund jffs2_free_full_dirent(fd); 325e231c2eeSDavid Howells return ERR_CAST(hold_err); 3265bd5c03cSJoakim Tjernlund } 3271da177e4SLinus Torvalds 3281da177e4SLinus Torvalds if (retried) { 329730554d9SArtem B. Bityutskiy jffs2_dbg_acct_sanity_check(c,NULL); 3301da177e4SLinus Torvalds } 3311da177e4SLinus Torvalds 3321da177e4SLinus Torvalds return fd; 3331da177e4SLinus Torvalds } 3341da177e4SLinus Torvalds 3351da177e4SLinus Torvalds /* The OS-specific code fills in the metadata in the jffs2_raw_inode for us, so that 3361da177e4SLinus Torvalds we don't have to go digging in struct inode or its equivalent. It should set: 3371da177e4SLinus Torvalds mode, uid, gid, (starting)isize, atime, ctime, mtime */ 3381da177e4SLinus Torvalds int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 3391da177e4SLinus Torvalds struct jffs2_raw_inode *ri, unsigned char *buf, 3401da177e4SLinus Torvalds uint32_t offset, uint32_t writelen, uint32_t *retlen) 3411da177e4SLinus Torvalds { 3421da177e4SLinus Torvalds int ret = 0; 3431da177e4SLinus Torvalds uint32_t writtenlen = 0; 3441da177e4SLinus Torvalds 3459c261b33SJoe Perches jffs2_dbg(1, "%s(): Ino #%u, ofs 0x%x, len 0x%x\n", 3469c261b33SJoe Perches __func__, f->inocache->ino, offset, writelen); 3471da177e4SLinus Torvalds 3481da177e4SLinus Torvalds while(writelen) { 3491da177e4SLinus Torvalds struct jffs2_full_dnode *fn; 3501da177e4SLinus Torvalds unsigned char *comprbuf = NULL; 3511da177e4SLinus Torvalds uint16_t comprtype = JFFS2_COMPR_NONE; 3529fe4854cSDavid Woodhouse uint32_t alloclen; 3531da177e4SLinus Torvalds uint32_t datalen, cdatalen; 3541da177e4SLinus Torvalds int retried = 0; 3551da177e4SLinus Torvalds 3561da177e4SLinus Torvalds retry: 3579c261b33SJoe Perches jffs2_dbg(2, "jffs2_commit_write() loop: 0x%x to write to 0x%x\n", 3589c261b33SJoe Perches writelen, offset); 3591da177e4SLinus Torvalds 3609fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN, 361e631ddbaSFerenc Havasi &alloclen, ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE); 3621da177e4SLinus Torvalds if (ret) { 3639c261b33SJoe Perches jffs2_dbg(1, "jffs2_reserve_space returned %d\n", ret); 3641da177e4SLinus Torvalds break; 3651da177e4SLinus Torvalds } 366ced22070SDavid Woodhouse mutex_lock(&f->sem); 3671da177e4SLinus Torvalds datalen = min_t(uint32_t, writelen, PAGE_CACHE_SIZE - (offset & (PAGE_CACHE_SIZE-1))); 3681da177e4SLinus Torvalds cdatalen = min_t(uint32_t, alloclen - sizeof(*ri), datalen); 3691da177e4SLinus Torvalds 3701da177e4SLinus Torvalds comprtype = jffs2_compress(c, f, buf, &comprbuf, &datalen, &cdatalen); 3711da177e4SLinus Torvalds 3721da177e4SLinus Torvalds ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 3731da177e4SLinus Torvalds ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE); 3741da177e4SLinus Torvalds ri->totlen = cpu_to_je32(sizeof(*ri) + cdatalen); 3751da177e4SLinus Torvalds ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 3761da177e4SLinus Torvalds 3771da177e4SLinus Torvalds ri->ino = cpu_to_je32(f->inocache->ino); 3781da177e4SLinus Torvalds ri->version = cpu_to_je32(++f->highest_version); 3791da177e4SLinus Torvalds ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen)); 3801da177e4SLinus Torvalds ri->offset = cpu_to_je32(offset); 3811da177e4SLinus Torvalds ri->csize = cpu_to_je32(cdatalen); 3821da177e4SLinus Torvalds ri->dsize = cpu_to_je32(datalen); 3831da177e4SLinus Torvalds ri->compr = comprtype & 0xff; 3841da177e4SLinus Torvalds ri->usercompr = (comprtype >> 8 ) & 0xff; 3851da177e4SLinus Torvalds ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 3861da177e4SLinus Torvalds ri->data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen)); 3871da177e4SLinus Torvalds 3889fe4854cSDavid Woodhouse fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, ALLOC_NORETRY); 3891da177e4SLinus Torvalds 3901da177e4SLinus Torvalds jffs2_free_comprbuf(comprbuf, buf); 3911da177e4SLinus Torvalds 3921da177e4SLinus Torvalds if (IS_ERR(fn)) { 3931da177e4SLinus Torvalds ret = PTR_ERR(fn); 394ced22070SDavid Woodhouse mutex_unlock(&f->sem); 3951da177e4SLinus Torvalds jffs2_complete_reservation(c); 3961da177e4SLinus Torvalds if (!retried) { 3971da177e4SLinus Torvalds /* Write error to be retried */ 3981da177e4SLinus Torvalds retried = 1; 3999c261b33SJoe Perches jffs2_dbg(1, "Retrying node write in jffs2_write_inode_range()\n"); 4001da177e4SLinus Torvalds goto retry; 4011da177e4SLinus Torvalds } 4021da177e4SLinus Torvalds break; 4031da177e4SLinus Torvalds } 4041da177e4SLinus Torvalds ret = jffs2_add_full_dnode_to_inode(c, f, fn); 4051da177e4SLinus Torvalds if (f->metadata) { 4061da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, f->metadata->raw); 4071da177e4SLinus Torvalds jffs2_free_full_dnode(f->metadata); 4081da177e4SLinus Torvalds f->metadata = NULL; 4091da177e4SLinus Torvalds } 4101da177e4SLinus Torvalds if (ret) { 4111da177e4SLinus Torvalds /* Eep */ 4129c261b33SJoe Perches jffs2_dbg(1, "Eep. add_full_dnode_to_inode() failed in commit_write, returned %d\n", 4139c261b33SJoe Perches ret); 4141da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, fn->raw); 4151da177e4SLinus Torvalds jffs2_free_full_dnode(fn); 4161da177e4SLinus Torvalds 417ced22070SDavid Woodhouse mutex_unlock(&f->sem); 4181da177e4SLinus Torvalds jffs2_complete_reservation(c); 4191da177e4SLinus Torvalds break; 4201da177e4SLinus Torvalds } 421ced22070SDavid Woodhouse mutex_unlock(&f->sem); 4221da177e4SLinus Torvalds jffs2_complete_reservation(c); 4231da177e4SLinus Torvalds if (!datalen) { 424da320f05SJoe Perches pr_warn("Eep. We didn't actually write any data in jffs2_write_inode_range()\n"); 4251da177e4SLinus Torvalds ret = -EIO; 4261da177e4SLinus Torvalds break; 4271da177e4SLinus Torvalds } 4289c261b33SJoe Perches jffs2_dbg(1, "increasing writtenlen by %d\n", datalen); 4291da177e4SLinus Torvalds writtenlen += datalen; 4301da177e4SLinus Torvalds offset += datalen; 4311da177e4SLinus Torvalds writelen -= datalen; 4321da177e4SLinus Torvalds buf += datalen; 4331da177e4SLinus Torvalds } 4341da177e4SLinus Torvalds *retlen = writtenlen; 4351da177e4SLinus Torvalds return ret; 4361da177e4SLinus Torvalds } 4371da177e4SLinus Torvalds 4382a7dba39SEric Paris int jffs2_do_create(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, 4392a7dba39SEric Paris struct jffs2_inode_info *f, struct jffs2_raw_inode *ri, 4402a7dba39SEric Paris const struct qstr *qstr) 4411da177e4SLinus Torvalds { 4421da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 4431da177e4SLinus Torvalds struct jffs2_full_dnode *fn; 4441da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 4459fe4854cSDavid Woodhouse uint32_t alloclen; 4461da177e4SLinus Torvalds int ret; 4471da177e4SLinus Torvalds 4481da177e4SLinus Torvalds /* Try to reserve enough space for both node and dirent. 4491da177e4SLinus Torvalds * Just the node will do for now, though 4501da177e4SLinus Torvalds */ 4519fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL, 452e631ddbaSFerenc Havasi JFFS2_SUMMARY_INODE_SIZE); 4539c261b33SJoe Perches jffs2_dbg(1, "%s(): reserved 0x%x bytes\n", __func__, alloclen); 454590fe34cSDavid Woodhouse if (ret) 4551da177e4SLinus Torvalds return ret; 456590fe34cSDavid Woodhouse 457590fe34cSDavid Woodhouse mutex_lock(&f->sem); 4581da177e4SLinus Torvalds 4591da177e4SLinus Torvalds ri->data_crc = cpu_to_je32(0); 4601da177e4SLinus Torvalds ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 4611da177e4SLinus Torvalds 4629fe4854cSDavid Woodhouse fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL); 4631da177e4SLinus Torvalds 4649c261b33SJoe Perches jffs2_dbg(1, "jffs2_do_create created file with mode 0x%x\n", 4659c261b33SJoe Perches jemode_to_cpu(ri->mode)); 4661da177e4SLinus Torvalds 4671da177e4SLinus Torvalds if (IS_ERR(fn)) { 4689c261b33SJoe Perches jffs2_dbg(1, "jffs2_write_dnode() failed\n"); 4691da177e4SLinus Torvalds /* Eeek. Wave bye bye */ 470ced22070SDavid Woodhouse mutex_unlock(&f->sem); 4711da177e4SLinus Torvalds jffs2_complete_reservation(c); 4721da177e4SLinus Torvalds return PTR_ERR(fn); 4731da177e4SLinus Torvalds } 4741da177e4SLinus Torvalds /* No data here. Only a metadata node, which will be 4751da177e4SLinus Torvalds obsoleted by the first data write 4761da177e4SLinus Torvalds */ 4771da177e4SLinus Torvalds f->metadata = fn; 4781da177e4SLinus Torvalds 479ced22070SDavid Woodhouse mutex_unlock(&f->sem); 4801da177e4SLinus Torvalds jffs2_complete_reservation(c); 481cfc8dc6fSKaiGai Kohei 4822a7dba39SEric Paris ret = jffs2_init_security(&f->vfs_inode, &dir_f->vfs_inode, qstr); 483cfc8dc6fSKaiGai Kohei if (ret) 484cfc8dc6fSKaiGai Kohei return ret; 485cfc8dc6fSKaiGai Kohei ret = jffs2_init_acl_post(&f->vfs_inode); 486cfc8dc6fSKaiGai Kohei if (ret) 487cfc8dc6fSKaiGai Kohei return ret; 488cfc8dc6fSKaiGai Kohei 4892a7dba39SEric Paris ret = jffs2_reserve_space(c, sizeof(*rd)+qstr->len, &alloclen, 4902a7dba39SEric Paris ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(qstr->len)); 4911da177e4SLinus Torvalds 4921da177e4SLinus Torvalds if (ret) { 4931da177e4SLinus Torvalds /* Eep. */ 4949c261b33SJoe Perches jffs2_dbg(1, "jffs2_reserve_space() for dirent failed\n"); 4951da177e4SLinus Torvalds return ret; 4961da177e4SLinus Torvalds } 4971da177e4SLinus Torvalds 4981da177e4SLinus Torvalds rd = jffs2_alloc_raw_dirent(); 4991da177e4SLinus Torvalds if (!rd) { 5001da177e4SLinus Torvalds /* Argh. Now we treat it like a normal delete */ 5011da177e4SLinus Torvalds jffs2_complete_reservation(c); 5021da177e4SLinus Torvalds return -ENOMEM; 5031da177e4SLinus Torvalds } 5041da177e4SLinus Torvalds 505ced22070SDavid Woodhouse mutex_lock(&dir_f->sem); 5061da177e4SLinus Torvalds 5071da177e4SLinus Torvalds rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 5081da177e4SLinus Torvalds rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 5092a7dba39SEric Paris rd->totlen = cpu_to_je32(sizeof(*rd) + qstr->len); 5101da177e4SLinus Torvalds rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 5111da177e4SLinus Torvalds 5121da177e4SLinus Torvalds rd->pino = cpu_to_je32(dir_f->inocache->ino); 5131da177e4SLinus Torvalds rd->version = cpu_to_je32(++dir_f->highest_version); 5141da177e4SLinus Torvalds rd->ino = ri->ino; 5151da177e4SLinus Torvalds rd->mctime = ri->ctime; 5162a7dba39SEric Paris rd->nsize = qstr->len; 5171da177e4SLinus Torvalds rd->type = DT_REG; 5181da177e4SLinus Torvalds rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 5192a7dba39SEric Paris rd->name_crc = cpu_to_je32(crc32(0, qstr->name, qstr->len)); 5201da177e4SLinus Torvalds 5212a7dba39SEric Paris fd = jffs2_write_dirent(c, dir_f, rd, qstr->name, qstr->len, ALLOC_NORMAL); 5221da177e4SLinus Torvalds 5231da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 5241da177e4SLinus Torvalds 5251da177e4SLinus Torvalds if (IS_ERR(fd)) { 5261da177e4SLinus Torvalds /* dirent failed to write. Delete the inode normally 5271da177e4SLinus Torvalds as if it were the final unlink() */ 5281da177e4SLinus Torvalds jffs2_complete_reservation(c); 529ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 5301da177e4SLinus Torvalds return PTR_ERR(fd); 5311da177e4SLinus Torvalds } 5321da177e4SLinus Torvalds 5331da177e4SLinus Torvalds /* Link the fd into the inode's list, obsoleting an old 5341da177e4SLinus Torvalds one if necessary. */ 5351da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &dir_f->dents); 5361da177e4SLinus Torvalds 5371da177e4SLinus Torvalds jffs2_complete_reservation(c); 538ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 5391da177e4SLinus Torvalds 5401da177e4SLinus Torvalds return 0; 5411da177e4SLinus Torvalds } 5421da177e4SLinus Torvalds 5431da177e4SLinus Torvalds 5441da177e4SLinus Torvalds int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, 5453a69e0cdSArtem B. Bityutskiy const char *name, int namelen, struct jffs2_inode_info *dead_f, 5463a69e0cdSArtem B. Bityutskiy uint32_t time) 5471da177e4SLinus Torvalds { 5481da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 5491da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 5509fe4854cSDavid Woodhouse uint32_t alloclen; 5511da177e4SLinus Torvalds int ret; 5521da177e4SLinus Torvalds 553a491486aSJoakim Tjernlund if (!jffs2_can_mark_obsolete(c)) { 5541da177e4SLinus Torvalds /* We can't mark stuff obsolete on the medium. We need to write a deletion dirent */ 5551da177e4SLinus Torvalds 5561da177e4SLinus Torvalds rd = jffs2_alloc_raw_dirent(); 5571da177e4SLinus Torvalds if (!rd) 5581da177e4SLinus Torvalds return -ENOMEM; 5591da177e4SLinus Torvalds 5609fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 561e631ddbaSFerenc Havasi ALLOC_DELETION, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 5621da177e4SLinus Torvalds if (ret) { 5631da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 5641da177e4SLinus Torvalds return ret; 5651da177e4SLinus Torvalds } 5661da177e4SLinus Torvalds 567ced22070SDavid Woodhouse mutex_lock(&dir_f->sem); 5681da177e4SLinus Torvalds 5691da177e4SLinus Torvalds /* Build a deletion node */ 5701da177e4SLinus Torvalds rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 5711da177e4SLinus Torvalds rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 5721da177e4SLinus Torvalds rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 5731da177e4SLinus Torvalds rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 5741da177e4SLinus Torvalds 5751da177e4SLinus Torvalds rd->pino = cpu_to_je32(dir_f->inocache->ino); 5761da177e4SLinus Torvalds rd->version = cpu_to_je32(++dir_f->highest_version); 5771da177e4SLinus Torvalds rd->ino = cpu_to_je32(0); 5783a69e0cdSArtem B. Bityutskiy rd->mctime = cpu_to_je32(time); 5791da177e4SLinus Torvalds rd->nsize = namelen; 5801da177e4SLinus Torvalds rd->type = DT_UNKNOWN; 5811da177e4SLinus Torvalds rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 5821da177e4SLinus Torvalds rd->name_crc = cpu_to_je32(crc32(0, name, namelen)); 5831da177e4SLinus Torvalds 5849fe4854cSDavid Woodhouse fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_DELETION); 5851da177e4SLinus Torvalds 5861da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 5871da177e4SLinus Torvalds 5881da177e4SLinus Torvalds if (IS_ERR(fd)) { 5891da177e4SLinus Torvalds jffs2_complete_reservation(c); 590ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 5911da177e4SLinus Torvalds return PTR_ERR(fd); 5921da177e4SLinus Torvalds } 5931da177e4SLinus Torvalds 5941da177e4SLinus Torvalds /* File it. This will mark the old one obsolete. */ 5951da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &dir_f->dents); 596ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 5971da177e4SLinus Torvalds } else { 5981da177e4SLinus Torvalds uint32_t nhash = full_name_hash(name, namelen); 5991da177e4SLinus Torvalds 600bf66737cSHarvey Harrison fd = dir_f->dents; 601b5748643SDavid Woodhouse /* We don't actually want to reserve any space, but we do 602b5748643SDavid Woodhouse want to be holding the alloc_sem when we write to flash */ 603ced22070SDavid Woodhouse mutex_lock(&c->alloc_sem); 604ced22070SDavid Woodhouse mutex_lock(&dir_f->sem); 6051da177e4SLinus Torvalds 60615953580SDavid Woodhouse for (fd = dir_f->dents; fd; fd = fd->next) { 60715953580SDavid Woodhouse if (fd->nhash == nhash && 60815953580SDavid Woodhouse !memcmp(fd->name, name, namelen) && 60915953580SDavid Woodhouse !fd->name[namelen]) { 6101da177e4SLinus Torvalds 6119c261b33SJoe Perches jffs2_dbg(1, "Marking old dirent node (ino #%u) @%08x obsolete\n", 6129c261b33SJoe Perches fd->ino, ref_offset(fd->raw)); 61315953580SDavid Woodhouse jffs2_mark_node_obsolete(c, fd->raw); 61415953580SDavid Woodhouse /* We don't want to remove it from the list immediately, 61515953580SDavid Woodhouse because that screws up getdents()/seek() semantics even 61615953580SDavid Woodhouse more than they're screwed already. Turn it into a 61715953580SDavid Woodhouse node-less deletion dirent instead -- a placeholder */ 61815953580SDavid Woodhouse fd->raw = NULL; 61915953580SDavid Woodhouse fd->ino = 0; 6201da177e4SLinus Torvalds break; 6211da177e4SLinus Torvalds } 6221da177e4SLinus Torvalds } 623ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 6241da177e4SLinus Torvalds } 6251da177e4SLinus Torvalds 6261da177e4SLinus Torvalds /* dead_f is NULL if this was a rename not a real unlink */ 6271da177e4SLinus Torvalds /* Also catch the !f->inocache case, where there was a dirent 6281da177e4SLinus Torvalds pointing to an inode which didn't exist. */ 6291da177e4SLinus Torvalds if (dead_f && dead_f->inocache) { 6301da177e4SLinus Torvalds 631ced22070SDavid Woodhouse mutex_lock(&dead_f->sem); 6321da177e4SLinus Torvalds 63332f1a95dSArtem B. Bityuckiy if (S_ISDIR(OFNI_EDONI_2SFFJ(dead_f)->i_mode)) { 6341da177e4SLinus Torvalds while (dead_f->dents) { 6351da177e4SLinus Torvalds /* There can be only deleted ones */ 6361da177e4SLinus Torvalds fd = dead_f->dents; 6371da177e4SLinus Torvalds 6381da177e4SLinus Torvalds dead_f->dents = fd->next; 6391da177e4SLinus Torvalds 6401da177e4SLinus Torvalds if (fd->ino) { 641da320f05SJoe Perches pr_warn("Deleting inode #%u with active dentry \"%s\"->ino #%u\n", 642da320f05SJoe Perches dead_f->inocache->ino, 643da320f05SJoe Perches fd->name, fd->ino); 6441da177e4SLinus Torvalds } else { 6459c261b33SJoe Perches jffs2_dbg(1, "Removing deletion dirent for \"%s\" from dir ino #%u\n", 6469c261b33SJoe Perches fd->name, 6479c261b33SJoe Perches dead_f->inocache->ino); 6481da177e4SLinus Torvalds } 64915953580SDavid Woodhouse if (fd->raw) 6501da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, fd->raw); 6511da177e4SLinus Torvalds jffs2_free_full_dirent(fd); 6521da177e4SLinus Torvalds } 65327c72b04SDavid Woodhouse dead_f->inocache->pino_nlink = 0; 65427c72b04SDavid Woodhouse } else 65527c72b04SDavid Woodhouse dead_f->inocache->pino_nlink--; 6561da177e4SLinus Torvalds /* NB: Caller must set inode nlink if appropriate */ 657ced22070SDavid Woodhouse mutex_unlock(&dead_f->sem); 6581da177e4SLinus Torvalds } 6591da177e4SLinus Torvalds 6601da177e4SLinus Torvalds jffs2_complete_reservation(c); 6611da177e4SLinus Torvalds 6621da177e4SLinus Torvalds return 0; 6631da177e4SLinus Torvalds } 6641da177e4SLinus Torvalds 6651da177e4SLinus Torvalds 6663a69e0cdSArtem B. Bityutskiy 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) 6671da177e4SLinus Torvalds { 6681da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 6691da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 6709fe4854cSDavid Woodhouse uint32_t alloclen; 6711da177e4SLinus Torvalds int ret; 6721da177e4SLinus Torvalds 6731da177e4SLinus Torvalds rd = jffs2_alloc_raw_dirent(); 6741da177e4SLinus Torvalds if (!rd) 6751da177e4SLinus Torvalds return -ENOMEM; 6761da177e4SLinus Torvalds 6779fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 678e631ddbaSFerenc Havasi ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 6791da177e4SLinus Torvalds if (ret) { 6801da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 6811da177e4SLinus Torvalds return ret; 6821da177e4SLinus Torvalds } 6831da177e4SLinus Torvalds 684ced22070SDavid Woodhouse mutex_lock(&dir_f->sem); 6851da177e4SLinus Torvalds 6861da177e4SLinus Torvalds /* Build a deletion node */ 6871da177e4SLinus Torvalds rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 6881da177e4SLinus Torvalds rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 6891da177e4SLinus Torvalds rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 6901da177e4SLinus Torvalds rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 6911da177e4SLinus Torvalds 6921da177e4SLinus Torvalds rd->pino = cpu_to_je32(dir_f->inocache->ino); 6931da177e4SLinus Torvalds rd->version = cpu_to_je32(++dir_f->highest_version); 6941da177e4SLinus Torvalds rd->ino = cpu_to_je32(ino); 6953a69e0cdSArtem B. Bityutskiy rd->mctime = cpu_to_je32(time); 6961da177e4SLinus Torvalds rd->nsize = namelen; 6971da177e4SLinus Torvalds 6981da177e4SLinus Torvalds rd->type = type; 6991da177e4SLinus Torvalds 7001da177e4SLinus Torvalds rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 7011da177e4SLinus Torvalds rd->name_crc = cpu_to_je32(crc32(0, name, namelen)); 7021da177e4SLinus Torvalds 7039fe4854cSDavid Woodhouse fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL); 7041da177e4SLinus Torvalds 7051da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 7061da177e4SLinus Torvalds 7071da177e4SLinus Torvalds if (IS_ERR(fd)) { 7081da177e4SLinus Torvalds jffs2_complete_reservation(c); 709ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 7101da177e4SLinus Torvalds return PTR_ERR(fd); 7111da177e4SLinus Torvalds } 7121da177e4SLinus Torvalds 7131da177e4SLinus Torvalds /* File it. This will mark the old one obsolete. */ 7141da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &dir_f->dents); 7151da177e4SLinus Torvalds 7161da177e4SLinus Torvalds jffs2_complete_reservation(c); 717ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 7181da177e4SLinus Torvalds 7191da177e4SLinus Torvalds return 0; 7201da177e4SLinus Torvalds } 721