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/slab.h> 161da177e4SLinus Torvalds #include <linux/pagemap.h> 171da177e4SLinus Torvalds #include <linux/mtd/mtd.h> 181da177e4SLinus Torvalds #include "nodelist.h" 191da177e4SLinus Torvalds #include "compr.h" 201da177e4SLinus Torvalds 211da177e4SLinus Torvalds 2227c72b04SDavid Woodhouse int jffs2_do_new_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 2327c72b04SDavid Woodhouse uint32_t mode, struct jffs2_raw_inode *ri) 241da177e4SLinus Torvalds { 251da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 261da177e4SLinus Torvalds 271da177e4SLinus Torvalds ic = jffs2_alloc_inode_cache(); 281da177e4SLinus Torvalds if (!ic) { 291da177e4SLinus Torvalds return -ENOMEM; 301da177e4SLinus Torvalds } 311da177e4SLinus Torvalds 321da177e4SLinus Torvalds memset(ic, 0, sizeof(*ic)); 331da177e4SLinus Torvalds 341da177e4SLinus Torvalds f->inocache = ic; 3527c72b04SDavid Woodhouse f->inocache->pino_nlink = 1; /* Will be overwritten shortly for directories */ 361da177e4SLinus Torvalds f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache; 371da177e4SLinus Torvalds f->inocache->state = INO_STATE_PRESENT; 381da177e4SLinus Torvalds 391da177e4SLinus Torvalds jffs2_add_ino_cache(c, f->inocache); 407d200960SDavid Woodhouse D1(printk(KERN_DEBUG "jffs2_do_new_inode(): Assigned ino# %d\n", f->inocache->ino)); 417d200960SDavid Woodhouse ri->ino = cpu_to_je32(f->inocache->ino); 421da177e4SLinus Torvalds 431da177e4SLinus Torvalds ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 441da177e4SLinus Torvalds ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE); 451da177e4SLinus Torvalds ri->totlen = cpu_to_je32(PAD(sizeof(*ri))); 461da177e4SLinus Torvalds ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 471da177e4SLinus Torvalds ri->mode = cpu_to_jemode(mode); 481da177e4SLinus Torvalds 491da177e4SLinus Torvalds f->highest_version = 1; 501da177e4SLinus Torvalds ri->version = cpu_to_je32(f->highest_version); 511da177e4SLinus Torvalds 521da177e4SLinus Torvalds return 0; 531da177e4SLinus Torvalds } 541da177e4SLinus Torvalds 551da177e4SLinus Torvalds /* jffs2_write_dnode - given a raw_inode, allocate a full_dnode for it, 561da177e4SLinus Torvalds write it to the flash, link it into the existing inode/fragment list */ 571da177e4SLinus Torvalds 589fe4854cSDavid Woodhouse struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 599fe4854cSDavid Woodhouse struct jffs2_raw_inode *ri, const unsigned char *data, 609fe4854cSDavid Woodhouse uint32_t datalen, int alloc_mode) 611da177e4SLinus Torvalds 621da177e4SLinus Torvalds { 631da177e4SLinus Torvalds struct jffs2_full_dnode *fn; 641da177e4SLinus Torvalds size_t retlen; 659fe4854cSDavid Woodhouse uint32_t flash_ofs; 661da177e4SLinus Torvalds struct kvec vecs[2]; 671da177e4SLinus Torvalds int ret; 681da177e4SLinus Torvalds int retried = 0; 691da177e4SLinus Torvalds unsigned long cnt = 2; 701da177e4SLinus Torvalds 711da177e4SLinus Torvalds D1(if(je32_to_cpu(ri->hdr_crc) != crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)) { 721da177e4SLinus Torvalds printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dnode()\n"); 731da177e4SLinus Torvalds BUG(); 741da177e4SLinus Torvalds } 751da177e4SLinus Torvalds ); 761da177e4SLinus Torvalds vecs[0].iov_base = ri; 771da177e4SLinus Torvalds vecs[0].iov_len = sizeof(*ri); 781da177e4SLinus Torvalds vecs[1].iov_base = (unsigned char *)data; 791da177e4SLinus Torvalds vecs[1].iov_len = datalen; 801da177e4SLinus Torvalds 811da177e4SLinus Torvalds if (je32_to_cpu(ri->totlen) != sizeof(*ri) + datalen) { 821da177e4SLinus Torvalds 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); 831da177e4SLinus Torvalds } 841da177e4SLinus Torvalds 851da177e4SLinus Torvalds fn = jffs2_alloc_full_dnode(); 862f785402SDavid Woodhouse if (!fn) 871da177e4SLinus Torvalds return ERR_PTR(-ENOMEM); 881da177e4SLinus Torvalds 891da177e4SLinus Torvalds /* check number of valid vecs */ 901da177e4SLinus Torvalds if (!datalen || !data) 911da177e4SLinus Torvalds cnt = 1; 921da177e4SLinus Torvalds retry: 932f785402SDavid Woodhouse flash_ofs = write_ofs(c); 949fe4854cSDavid Woodhouse 959fe4854cSDavid Woodhouse jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len); 961da177e4SLinus Torvalds 979b88f473SEstelle Hammache if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(ri->version) < f->highest_version)) { 989b88f473SEstelle Hammache BUG_ON(!retried); 999b88f473SEstelle Hammache D1(printk(KERN_DEBUG "jffs2_write_dnode : dnode_version %d, " 1009b88f473SEstelle Hammache "highest version %d -> updating dnode\n", 101e4803c30SEstelle Hammache je32_to_cpu(ri->version), f->highest_version)); 102e4803c30SEstelle Hammache ri->version = cpu_to_je32(++f->highest_version); 103e4803c30SEstelle Hammache ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 104e4803c30SEstelle Hammache } 105e4803c30SEstelle Hammache 1061da177e4SLinus Torvalds ret = jffs2_flash_writev(c, vecs, cnt, flash_ofs, &retlen, 1071da177e4SLinus Torvalds (alloc_mode==ALLOC_GC)?0:f->inocache->ino); 1081da177e4SLinus Torvalds 1091da177e4SLinus Torvalds if (ret || (retlen != sizeof(*ri) + datalen)) { 1101da177e4SLinus Torvalds printk(KERN_NOTICE "Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n", 1111da177e4SLinus Torvalds sizeof(*ri)+datalen, flash_ofs, ret, retlen); 1121da177e4SLinus Torvalds 1131da177e4SLinus Torvalds /* Mark the space as dirtied */ 1141da177e4SLinus Torvalds if (retlen) { 1151da177e4SLinus Torvalds /* Don't change raw->size to match retlen. We may have 1161da177e4SLinus Torvalds written the node header already, and only the data will 1171da177e4SLinus Torvalds seem corrupted, in which case the scan would skip over 1181da177e4SLinus Torvalds any node we write before the original intended end of 1191da177e4SLinus Torvalds this node */ 1202f785402SDavid Woodhouse jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*ri)+datalen), NULL); 1211da177e4SLinus Torvalds } else { 1222f785402SDavid Woodhouse printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", flash_ofs); 1231da177e4SLinus Torvalds } 1242f785402SDavid Woodhouse if (!retried && alloc_mode != ALLOC_NORETRY) { 1251da177e4SLinus Torvalds /* Try to reallocate space and retry */ 1261da177e4SLinus Torvalds uint32_t dummy; 1271da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size]; 1281da177e4SLinus Torvalds 1291da177e4SLinus Torvalds retried = 1; 1301da177e4SLinus Torvalds 1311da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Retrying failed write.\n")); 1321da177e4SLinus Torvalds 133730554d9SArtem B. Bityutskiy jffs2_dbg_acct_sanity_check(c,jeb); 134730554d9SArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check(c, jeb); 1351da177e4SLinus Torvalds 1361da177e4SLinus Torvalds if (alloc_mode == ALLOC_GC) { 1379fe4854cSDavid Woodhouse ret = jffs2_reserve_space_gc(c, sizeof(*ri) + datalen, &dummy, 1389fe4854cSDavid Woodhouse JFFS2_SUMMARY_INODE_SIZE); 1391da177e4SLinus Torvalds } else { 1401da177e4SLinus Torvalds /* Locking pain */ 141ced22070SDavid Woodhouse mutex_unlock(&f->sem); 1421da177e4SLinus Torvalds jffs2_complete_reservation(c); 1431da177e4SLinus Torvalds 1449fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*ri) + datalen, &dummy, 1459fe4854cSDavid Woodhouse alloc_mode, JFFS2_SUMMARY_INODE_SIZE); 146ced22070SDavid Woodhouse mutex_lock(&f->sem); 1471da177e4SLinus Torvalds } 1481da177e4SLinus Torvalds 1491da177e4SLinus Torvalds if (!ret) { 1509fe4854cSDavid Woodhouse flash_ofs = write_ofs(c); 1511da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs)); 1521da177e4SLinus Torvalds 153730554d9SArtem B. Bityutskiy jffs2_dbg_acct_sanity_check(c,jeb); 154730554d9SArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check(c, jeb); 1551da177e4SLinus Torvalds 1561da177e4SLinus Torvalds goto retry; 1571da177e4SLinus Torvalds } 1581da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret)); 1591da177e4SLinus Torvalds } 1601da177e4SLinus Torvalds /* Release the full_dnode which is now useless, and return */ 1611da177e4SLinus Torvalds jffs2_free_full_dnode(fn); 1621da177e4SLinus Torvalds return ERR_PTR(ret?ret:-EIO); 1631da177e4SLinus Torvalds } 1641da177e4SLinus Torvalds /* Mark the space used */ 1651da177e4SLinus Torvalds /* If node covers at least a whole page, or if it starts at the 1661da177e4SLinus Torvalds beginning of a page and runs to the end of the file, or if 1671da177e4SLinus Torvalds it's a hole node, mark it REF_PRISTINE, else REF_NORMAL. 1681da177e4SLinus Torvalds */ 1691da177e4SLinus Torvalds if ((je32_to_cpu(ri->dsize) >= PAGE_CACHE_SIZE) || 1701da177e4SLinus Torvalds ( ((je32_to_cpu(ri->offset)&(PAGE_CACHE_SIZE-1))==0) && 1711da177e4SLinus Torvalds (je32_to_cpu(ri->dsize)+je32_to_cpu(ri->offset) == je32_to_cpu(ri->isize)))) { 1722f785402SDavid Woodhouse flash_ofs |= REF_PRISTINE; 1731da177e4SLinus Torvalds } else { 1742f785402SDavid Woodhouse flash_ofs |= REF_NORMAL; 1751da177e4SLinus Torvalds } 1762f785402SDavid Woodhouse fn->raw = jffs2_add_physical_node_ref(c, flash_ofs, PAD(sizeof(*ri)+datalen), f->inocache); 1775bd5c03cSJoakim Tjernlund if (IS_ERR(fn->raw)) { 1785bd5c03cSJoakim Tjernlund void *hold_err = fn->raw; 1795bd5c03cSJoakim Tjernlund /* Release the full_dnode which is now useless, and return */ 1805bd5c03cSJoakim Tjernlund jffs2_free_full_dnode(fn); 181e231c2eeSDavid Howells return ERR_CAST(hold_err); 1825bd5c03cSJoakim Tjernlund } 1832f785402SDavid Woodhouse fn->ofs = je32_to_cpu(ri->offset); 1842f785402SDavid Woodhouse fn->size = je32_to_cpu(ri->dsize); 1852f785402SDavid Woodhouse fn->frags = 0; 1861da177e4SLinus Torvalds 1871da177e4SLinus Torvalds 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", 1882f785402SDavid Woodhouse flash_ofs & ~3, flash_ofs & 3, je32_to_cpu(ri->dsize), 1891da177e4SLinus Torvalds je32_to_cpu(ri->csize), je32_to_cpu(ri->node_crc), 1901da177e4SLinus Torvalds je32_to_cpu(ri->data_crc), je32_to_cpu(ri->totlen))); 1911da177e4SLinus Torvalds 1921da177e4SLinus Torvalds if (retried) { 193730554d9SArtem B. Bityutskiy jffs2_dbg_acct_sanity_check(c,NULL); 1941da177e4SLinus Torvalds } 1951da177e4SLinus Torvalds 1961da177e4SLinus Torvalds return fn; 1971da177e4SLinus Torvalds } 1981da177e4SLinus Torvalds 1999fe4854cSDavid Woodhouse struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 2009fe4854cSDavid Woodhouse struct jffs2_raw_dirent *rd, const unsigned char *name, 2019fe4854cSDavid Woodhouse uint32_t namelen, int alloc_mode) 2021da177e4SLinus Torvalds { 2031da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 2041da177e4SLinus Torvalds size_t retlen; 2051da177e4SLinus Torvalds struct kvec vecs[2]; 2062f785402SDavid Woodhouse uint32_t flash_ofs; 2071da177e4SLinus Torvalds int retried = 0; 2081da177e4SLinus Torvalds int ret; 2091da177e4SLinus Torvalds 2101da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_write_dirent(ino #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x)\n", 2111da177e4SLinus Torvalds je32_to_cpu(rd->pino), name, name, je32_to_cpu(rd->ino), 2121da177e4SLinus Torvalds je32_to_cpu(rd->name_crc))); 213730554d9SArtem B. Bityutskiy 2141da177e4SLinus Torvalds D1(if(je32_to_cpu(rd->hdr_crc) != crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)) { 2151da177e4SLinus Torvalds printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dirent()\n"); 2161da177e4SLinus Torvalds BUG(); 2172f785402SDavid Woodhouse }); 2181da177e4SLinus Torvalds 21969ca4378SDavid Woodhouse if (strnlen(name, namelen) != namelen) { 22069ca4378SDavid Woodhouse /* This should never happen, but seems to have done on at least one 22169ca4378SDavid Woodhouse occasion: https://dev.laptop.org/ticket/4184 */ 22269ca4378SDavid Woodhouse printk(KERN_CRIT "Error in jffs2_write_dirent() -- name contains zero bytes!\n"); 22369ca4378SDavid Woodhouse printk(KERN_CRIT "Directory inode #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x\n", 22469ca4378SDavid Woodhouse je32_to_cpu(rd->pino), name, name, je32_to_cpu(rd->ino), 22569ca4378SDavid Woodhouse je32_to_cpu(rd->name_crc)); 22669ca4378SDavid Woodhouse WARN_ON(1); 22769ca4378SDavid Woodhouse return ERR_PTR(-EIO); 22869ca4378SDavid Woodhouse } 22969ca4378SDavid Woodhouse 2301da177e4SLinus Torvalds vecs[0].iov_base = rd; 2311da177e4SLinus Torvalds vecs[0].iov_len = sizeof(*rd); 2321da177e4SLinus Torvalds vecs[1].iov_base = (unsigned char *)name; 2331da177e4SLinus Torvalds vecs[1].iov_len = namelen; 2341da177e4SLinus Torvalds 2351da177e4SLinus Torvalds fd = jffs2_alloc_full_dirent(namelen+1); 2362f785402SDavid Woodhouse if (!fd) 2371da177e4SLinus Torvalds return ERR_PTR(-ENOMEM); 2381da177e4SLinus Torvalds 2391da177e4SLinus Torvalds fd->version = je32_to_cpu(rd->version); 2401da177e4SLinus Torvalds fd->ino = je32_to_cpu(rd->ino); 24169ca4378SDavid Woodhouse fd->nhash = full_name_hash(name, namelen); 2421da177e4SLinus Torvalds fd->type = rd->type; 2431da177e4SLinus Torvalds memcpy(fd->name, name, namelen); 2441da177e4SLinus Torvalds fd->name[namelen]=0; 2451da177e4SLinus Torvalds 2461da177e4SLinus Torvalds retry: 2472f785402SDavid Woodhouse flash_ofs = write_ofs(c); 2481da177e4SLinus Torvalds 2492f785402SDavid Woodhouse jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len); 2501da177e4SLinus Torvalds 2519b88f473SEstelle Hammache if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(rd->version) < f->highest_version)) { 2529b88f473SEstelle Hammache BUG_ON(!retried); 2539b88f473SEstelle Hammache D1(printk(KERN_DEBUG "jffs2_write_dirent : dirent_version %d, " 2549b88f473SEstelle Hammache "highest version %d -> updating dirent\n", 255e4803c30SEstelle Hammache je32_to_cpu(rd->version), f->highest_version)); 256e4803c30SEstelle Hammache rd->version = cpu_to_je32(++f->highest_version); 257e4803c30SEstelle Hammache fd->version = je32_to_cpu(rd->version); 258e4803c30SEstelle Hammache rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 259e4803c30SEstelle Hammache } 260e4803c30SEstelle Hammache 2611da177e4SLinus Torvalds ret = jffs2_flash_writev(c, vecs, 2, flash_ofs, &retlen, 2621da177e4SLinus Torvalds (alloc_mode==ALLOC_GC)?0:je32_to_cpu(rd->pino)); 2631da177e4SLinus Torvalds if (ret || (retlen != sizeof(*rd) + namelen)) { 2641da177e4SLinus Torvalds printk(KERN_NOTICE "Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n", 2651da177e4SLinus Torvalds sizeof(*rd)+namelen, flash_ofs, ret, retlen); 2661da177e4SLinus Torvalds /* Mark the space as dirtied */ 2671da177e4SLinus Torvalds if (retlen) { 2682f785402SDavid Woodhouse jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*rd)+namelen), NULL); 2691da177e4SLinus Torvalds } else { 2702f785402SDavid Woodhouse printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", flash_ofs); 2711da177e4SLinus Torvalds } 2722f785402SDavid Woodhouse if (!retried) { 2731da177e4SLinus Torvalds /* Try to reallocate space and retry */ 2741da177e4SLinus Torvalds uint32_t dummy; 2751da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size]; 2761da177e4SLinus Torvalds 2771da177e4SLinus Torvalds retried = 1; 2781da177e4SLinus Torvalds 2791da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Retrying failed write.\n")); 2801da177e4SLinus Torvalds 281730554d9SArtem B. Bityutskiy jffs2_dbg_acct_sanity_check(c,jeb); 282730554d9SArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check(c, jeb); 2831da177e4SLinus Torvalds 2841da177e4SLinus Torvalds if (alloc_mode == ALLOC_GC) { 2859fe4854cSDavid Woodhouse ret = jffs2_reserve_space_gc(c, sizeof(*rd) + namelen, &dummy, 2869fe4854cSDavid Woodhouse JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 2871da177e4SLinus Torvalds } else { 2881da177e4SLinus Torvalds /* Locking pain */ 289ced22070SDavid Woodhouse mutex_unlock(&f->sem); 2901da177e4SLinus Torvalds jffs2_complete_reservation(c); 2911da177e4SLinus Torvalds 2929fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*rd) + namelen, &dummy, 2939fe4854cSDavid Woodhouse alloc_mode, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 294ced22070SDavid Woodhouse mutex_lock(&f->sem); 2951da177e4SLinus Torvalds } 2961da177e4SLinus Torvalds 2971da177e4SLinus Torvalds if (!ret) { 2989fe4854cSDavid Woodhouse flash_ofs = write_ofs(c); 2991da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs)); 300730554d9SArtem B. Bityutskiy jffs2_dbg_acct_sanity_check(c,jeb); 301730554d9SArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check(c, jeb); 3021da177e4SLinus Torvalds goto retry; 3031da177e4SLinus Torvalds } 3041da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret)); 3051da177e4SLinus Torvalds } 3061da177e4SLinus Torvalds /* Release the full_dnode which is now useless, and return */ 3071da177e4SLinus Torvalds jffs2_free_full_dirent(fd); 3081da177e4SLinus Torvalds return ERR_PTR(ret?ret:-EIO); 3091da177e4SLinus Torvalds } 3101da177e4SLinus Torvalds /* Mark the space used */ 31171c23397SDavid Woodhouse fd->raw = jffs2_add_physical_node_ref(c, flash_ofs | dirent_node_state(rd), 31271c23397SDavid Woodhouse PAD(sizeof(*rd)+namelen), f->inocache); 3135bd5c03cSJoakim Tjernlund if (IS_ERR(fd->raw)) { 3145bd5c03cSJoakim Tjernlund void *hold_err = fd->raw; 3155bd5c03cSJoakim Tjernlund /* Release the full_dirent which is now useless, and return */ 3165bd5c03cSJoakim Tjernlund jffs2_free_full_dirent(fd); 317e231c2eeSDavid Howells return ERR_CAST(hold_err); 3185bd5c03cSJoakim Tjernlund } 3191da177e4SLinus Torvalds 3201da177e4SLinus Torvalds if (retried) { 321730554d9SArtem B. Bityutskiy jffs2_dbg_acct_sanity_check(c,NULL); 3221da177e4SLinus Torvalds } 3231da177e4SLinus Torvalds 3241da177e4SLinus Torvalds return fd; 3251da177e4SLinus Torvalds } 3261da177e4SLinus Torvalds 3271da177e4SLinus Torvalds /* The OS-specific code fills in the metadata in the jffs2_raw_inode for us, so that 3281da177e4SLinus Torvalds we don't have to go digging in struct inode or its equivalent. It should set: 3291da177e4SLinus Torvalds mode, uid, gid, (starting)isize, atime, ctime, mtime */ 3301da177e4SLinus Torvalds int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 3311da177e4SLinus Torvalds struct jffs2_raw_inode *ri, unsigned char *buf, 3321da177e4SLinus Torvalds uint32_t offset, uint32_t writelen, uint32_t *retlen) 3331da177e4SLinus Torvalds { 3341da177e4SLinus Torvalds int ret = 0; 3351da177e4SLinus Torvalds uint32_t writtenlen = 0; 3361da177e4SLinus Torvalds 3371da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_write_inode_range(): Ino #%u, ofs 0x%x, len 0x%x\n", 3381da177e4SLinus Torvalds f->inocache->ino, offset, writelen)); 3391da177e4SLinus Torvalds 3401da177e4SLinus Torvalds while(writelen) { 3411da177e4SLinus Torvalds struct jffs2_full_dnode *fn; 3421da177e4SLinus Torvalds unsigned char *comprbuf = NULL; 3431da177e4SLinus Torvalds uint16_t comprtype = JFFS2_COMPR_NONE; 3449fe4854cSDavid Woodhouse uint32_t alloclen; 3451da177e4SLinus Torvalds uint32_t datalen, cdatalen; 3461da177e4SLinus Torvalds int retried = 0; 3471da177e4SLinus Torvalds 3481da177e4SLinus Torvalds retry: 3491da177e4SLinus Torvalds D2(printk(KERN_DEBUG "jffs2_commit_write() loop: 0x%x to write to 0x%x\n", writelen, offset)); 3501da177e4SLinus Torvalds 3519fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN, 352e631ddbaSFerenc Havasi &alloclen, ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE); 3531da177e4SLinus Torvalds if (ret) { 3541da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_reserve_space returned %d\n", ret)); 3551da177e4SLinus Torvalds break; 3561da177e4SLinus Torvalds } 357ced22070SDavid Woodhouse mutex_lock(&f->sem); 3581da177e4SLinus Torvalds datalen = min_t(uint32_t, writelen, PAGE_CACHE_SIZE - (offset & (PAGE_CACHE_SIZE-1))); 3591da177e4SLinus Torvalds cdatalen = min_t(uint32_t, alloclen - sizeof(*ri), datalen); 3601da177e4SLinus Torvalds 3611da177e4SLinus Torvalds comprtype = jffs2_compress(c, f, buf, &comprbuf, &datalen, &cdatalen); 3621da177e4SLinus Torvalds 3631da177e4SLinus Torvalds ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 3641da177e4SLinus Torvalds ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE); 3651da177e4SLinus Torvalds ri->totlen = cpu_to_je32(sizeof(*ri) + cdatalen); 3661da177e4SLinus Torvalds ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 3671da177e4SLinus Torvalds 3681da177e4SLinus Torvalds ri->ino = cpu_to_je32(f->inocache->ino); 3691da177e4SLinus Torvalds ri->version = cpu_to_je32(++f->highest_version); 3701da177e4SLinus Torvalds ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen)); 3711da177e4SLinus Torvalds ri->offset = cpu_to_je32(offset); 3721da177e4SLinus Torvalds ri->csize = cpu_to_je32(cdatalen); 3731da177e4SLinus Torvalds ri->dsize = cpu_to_je32(datalen); 3741da177e4SLinus Torvalds ri->compr = comprtype & 0xff; 3751da177e4SLinus Torvalds ri->usercompr = (comprtype >> 8 ) & 0xff; 3761da177e4SLinus Torvalds ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 3771da177e4SLinus Torvalds ri->data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen)); 3781da177e4SLinus Torvalds 3799fe4854cSDavid Woodhouse fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, ALLOC_NORETRY); 3801da177e4SLinus Torvalds 3811da177e4SLinus Torvalds jffs2_free_comprbuf(comprbuf, buf); 3821da177e4SLinus Torvalds 3831da177e4SLinus Torvalds if (IS_ERR(fn)) { 3841da177e4SLinus Torvalds ret = PTR_ERR(fn); 385ced22070SDavid Woodhouse mutex_unlock(&f->sem); 3861da177e4SLinus Torvalds jffs2_complete_reservation(c); 3871da177e4SLinus Torvalds if (!retried) { 3881da177e4SLinus Torvalds /* Write error to be retried */ 3891da177e4SLinus Torvalds retried = 1; 3901da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Retrying node write in jffs2_write_inode_range()\n")); 3911da177e4SLinus Torvalds goto retry; 3921da177e4SLinus Torvalds } 3931da177e4SLinus Torvalds break; 3941da177e4SLinus Torvalds } 3951da177e4SLinus Torvalds ret = jffs2_add_full_dnode_to_inode(c, f, fn); 3961da177e4SLinus Torvalds if (f->metadata) { 3971da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, f->metadata->raw); 3981da177e4SLinus Torvalds jffs2_free_full_dnode(f->metadata); 3991da177e4SLinus Torvalds f->metadata = NULL; 4001da177e4SLinus Torvalds } 4011da177e4SLinus Torvalds if (ret) { 4021da177e4SLinus Torvalds /* Eep */ 4031da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Eep. add_full_dnode_to_inode() failed in commit_write, returned %d\n", ret)); 4041da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, fn->raw); 4051da177e4SLinus Torvalds jffs2_free_full_dnode(fn); 4061da177e4SLinus Torvalds 407ced22070SDavid Woodhouse mutex_unlock(&f->sem); 4081da177e4SLinus Torvalds jffs2_complete_reservation(c); 4091da177e4SLinus Torvalds break; 4101da177e4SLinus Torvalds } 411ced22070SDavid Woodhouse mutex_unlock(&f->sem); 4121da177e4SLinus Torvalds jffs2_complete_reservation(c); 4131da177e4SLinus Torvalds if (!datalen) { 4141da177e4SLinus Torvalds printk(KERN_WARNING "Eep. We didn't actually write any data in jffs2_write_inode_range()\n"); 4151da177e4SLinus Torvalds ret = -EIO; 4161da177e4SLinus Torvalds break; 4171da177e4SLinus Torvalds } 4181da177e4SLinus Torvalds D1(printk(KERN_DEBUG "increasing writtenlen by %d\n", datalen)); 4191da177e4SLinus Torvalds writtenlen += datalen; 4201da177e4SLinus Torvalds offset += datalen; 4211da177e4SLinus Torvalds writelen -= datalen; 4221da177e4SLinus Torvalds buf += datalen; 4231da177e4SLinus Torvalds } 4241da177e4SLinus Torvalds *retlen = writtenlen; 4251da177e4SLinus Torvalds return ret; 4261da177e4SLinus Torvalds } 4271da177e4SLinus Torvalds 4281da177e4SLinus Torvalds int jffs2_do_create(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, struct jffs2_inode_info *f, struct jffs2_raw_inode *ri, const char *name, int namelen) 4291da177e4SLinus Torvalds { 4301da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 4311da177e4SLinus Torvalds struct jffs2_full_dnode *fn; 4321da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 4339fe4854cSDavid Woodhouse uint32_t alloclen; 4341da177e4SLinus Torvalds int ret; 4351da177e4SLinus Torvalds 4361da177e4SLinus Torvalds /* Try to reserve enough space for both node and dirent. 4371da177e4SLinus Torvalds * Just the node will do for now, though 4381da177e4SLinus Torvalds */ 4399fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL, 440e631ddbaSFerenc Havasi JFFS2_SUMMARY_INODE_SIZE); 4411da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_do_create(): reserved 0x%x bytes\n", alloclen)); 442590fe34cSDavid Woodhouse if (ret) 4431da177e4SLinus Torvalds return ret; 444590fe34cSDavid Woodhouse 445590fe34cSDavid Woodhouse mutex_lock(&f->sem); 4461da177e4SLinus Torvalds 4471da177e4SLinus Torvalds ri->data_crc = cpu_to_je32(0); 4481da177e4SLinus Torvalds ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 4491da177e4SLinus Torvalds 4509fe4854cSDavid Woodhouse fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL); 4511da177e4SLinus Torvalds 4521da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_do_create created file with mode 0x%x\n", 4531da177e4SLinus Torvalds jemode_to_cpu(ri->mode))); 4541da177e4SLinus Torvalds 4551da177e4SLinus Torvalds if (IS_ERR(fn)) { 4561da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_write_dnode() failed\n")); 4571da177e4SLinus Torvalds /* Eeek. Wave bye bye */ 458ced22070SDavid Woodhouse mutex_unlock(&f->sem); 4591da177e4SLinus Torvalds jffs2_complete_reservation(c); 4601da177e4SLinus Torvalds return PTR_ERR(fn); 4611da177e4SLinus Torvalds } 4621da177e4SLinus Torvalds /* No data here. Only a metadata node, which will be 4631da177e4SLinus Torvalds obsoleted by the first data write 4641da177e4SLinus Torvalds */ 4651da177e4SLinus Torvalds f->metadata = fn; 4661da177e4SLinus Torvalds 467ced22070SDavid Woodhouse mutex_unlock(&f->sem); 4681da177e4SLinus Torvalds jffs2_complete_reservation(c); 469cfc8dc6fSKaiGai Kohei 470cfc8dc6fSKaiGai Kohei ret = jffs2_init_security(&f->vfs_inode, &dir_f->vfs_inode); 471cfc8dc6fSKaiGai Kohei if (ret) 472cfc8dc6fSKaiGai Kohei return ret; 473cfc8dc6fSKaiGai Kohei ret = jffs2_init_acl_post(&f->vfs_inode); 474cfc8dc6fSKaiGai Kohei if (ret) 475cfc8dc6fSKaiGai Kohei return ret; 476cfc8dc6fSKaiGai Kohei 4779fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 478e631ddbaSFerenc Havasi ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 4791da177e4SLinus Torvalds 4801da177e4SLinus Torvalds if (ret) { 4811da177e4SLinus Torvalds /* Eep. */ 4821da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_reserve_space() for dirent failed\n")); 4831da177e4SLinus Torvalds return ret; 4841da177e4SLinus Torvalds } 4851da177e4SLinus Torvalds 4861da177e4SLinus Torvalds rd = jffs2_alloc_raw_dirent(); 4871da177e4SLinus Torvalds if (!rd) { 4881da177e4SLinus Torvalds /* Argh. Now we treat it like a normal delete */ 4891da177e4SLinus Torvalds jffs2_complete_reservation(c); 4901da177e4SLinus Torvalds return -ENOMEM; 4911da177e4SLinus Torvalds } 4921da177e4SLinus Torvalds 493ced22070SDavid Woodhouse mutex_lock(&dir_f->sem); 4941da177e4SLinus Torvalds 4951da177e4SLinus Torvalds rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 4961da177e4SLinus Torvalds rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 4971da177e4SLinus Torvalds rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 4981da177e4SLinus Torvalds rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 4991da177e4SLinus Torvalds 5001da177e4SLinus Torvalds rd->pino = cpu_to_je32(dir_f->inocache->ino); 5011da177e4SLinus Torvalds rd->version = cpu_to_je32(++dir_f->highest_version); 5021da177e4SLinus Torvalds rd->ino = ri->ino; 5031da177e4SLinus Torvalds rd->mctime = ri->ctime; 5041da177e4SLinus Torvalds rd->nsize = namelen; 5051da177e4SLinus Torvalds rd->type = DT_REG; 5061da177e4SLinus Torvalds rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 5071da177e4SLinus Torvalds rd->name_crc = cpu_to_je32(crc32(0, name, namelen)); 5081da177e4SLinus Torvalds 5099fe4854cSDavid Woodhouse fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL); 5101da177e4SLinus Torvalds 5111da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 5121da177e4SLinus Torvalds 5131da177e4SLinus Torvalds if (IS_ERR(fd)) { 5141da177e4SLinus Torvalds /* dirent failed to write. Delete the inode normally 5151da177e4SLinus Torvalds as if it were the final unlink() */ 5161da177e4SLinus Torvalds jffs2_complete_reservation(c); 517ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 5181da177e4SLinus Torvalds return PTR_ERR(fd); 5191da177e4SLinus Torvalds } 5201da177e4SLinus Torvalds 5211da177e4SLinus Torvalds /* Link the fd into the inode's list, obsoleting an old 5221da177e4SLinus Torvalds one if necessary. */ 5231da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &dir_f->dents); 5241da177e4SLinus Torvalds 5251da177e4SLinus Torvalds jffs2_complete_reservation(c); 526ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 5271da177e4SLinus Torvalds 5281da177e4SLinus Torvalds return 0; 5291da177e4SLinus Torvalds } 5301da177e4SLinus Torvalds 5311da177e4SLinus Torvalds 5321da177e4SLinus Torvalds int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, 5333a69e0cdSArtem B. Bityutskiy const char *name, int namelen, struct jffs2_inode_info *dead_f, 5343a69e0cdSArtem B. Bityutskiy uint32_t time) 5351da177e4SLinus Torvalds { 5361da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 5371da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 5389fe4854cSDavid Woodhouse uint32_t alloclen; 5391da177e4SLinus Torvalds int ret; 5401da177e4SLinus Torvalds 541a491486aSJoakim Tjernlund if (!jffs2_can_mark_obsolete(c)) { 5421da177e4SLinus Torvalds /* We can't mark stuff obsolete on the medium. We need to write a deletion dirent */ 5431da177e4SLinus Torvalds 5441da177e4SLinus Torvalds rd = jffs2_alloc_raw_dirent(); 5451da177e4SLinus Torvalds if (!rd) 5461da177e4SLinus Torvalds return -ENOMEM; 5471da177e4SLinus Torvalds 5489fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 549e631ddbaSFerenc Havasi ALLOC_DELETION, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 5501da177e4SLinus Torvalds if (ret) { 5511da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 5521da177e4SLinus Torvalds return ret; 5531da177e4SLinus Torvalds } 5541da177e4SLinus Torvalds 555ced22070SDavid Woodhouse mutex_lock(&dir_f->sem); 5561da177e4SLinus Torvalds 5571da177e4SLinus Torvalds /* Build a deletion node */ 5581da177e4SLinus Torvalds rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 5591da177e4SLinus Torvalds rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 5601da177e4SLinus Torvalds rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 5611da177e4SLinus Torvalds rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 5621da177e4SLinus Torvalds 5631da177e4SLinus Torvalds rd->pino = cpu_to_je32(dir_f->inocache->ino); 5641da177e4SLinus Torvalds rd->version = cpu_to_je32(++dir_f->highest_version); 5651da177e4SLinus Torvalds rd->ino = cpu_to_je32(0); 5663a69e0cdSArtem B. Bityutskiy rd->mctime = cpu_to_je32(time); 5671da177e4SLinus Torvalds rd->nsize = namelen; 5681da177e4SLinus Torvalds rd->type = DT_UNKNOWN; 5691da177e4SLinus Torvalds rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 5701da177e4SLinus Torvalds rd->name_crc = cpu_to_je32(crc32(0, name, namelen)); 5711da177e4SLinus Torvalds 5729fe4854cSDavid Woodhouse fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_DELETION); 5731da177e4SLinus Torvalds 5741da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 5751da177e4SLinus Torvalds 5761da177e4SLinus Torvalds if (IS_ERR(fd)) { 5771da177e4SLinus Torvalds jffs2_complete_reservation(c); 578ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 5791da177e4SLinus Torvalds return PTR_ERR(fd); 5801da177e4SLinus Torvalds } 5811da177e4SLinus Torvalds 5821da177e4SLinus Torvalds /* File it. This will mark the old one obsolete. */ 5831da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &dir_f->dents); 584ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 5851da177e4SLinus Torvalds } else { 5861da177e4SLinus Torvalds uint32_t nhash = full_name_hash(name, namelen); 5871da177e4SLinus Torvalds 588bf66737cSHarvey Harrison fd = dir_f->dents; 589b5748643SDavid Woodhouse /* We don't actually want to reserve any space, but we do 590b5748643SDavid Woodhouse want to be holding the alloc_sem when we write to flash */ 591ced22070SDavid Woodhouse mutex_lock(&c->alloc_sem); 592ced22070SDavid Woodhouse mutex_lock(&dir_f->sem); 5931da177e4SLinus Torvalds 59415953580SDavid Woodhouse for (fd = dir_f->dents; fd; fd = fd->next) { 59515953580SDavid Woodhouse if (fd->nhash == nhash && 59615953580SDavid Woodhouse !memcmp(fd->name, name, namelen) && 59715953580SDavid Woodhouse !fd->name[namelen]) { 5981da177e4SLinus Torvalds 5991da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Marking old dirent node (ino #%u) @%08x obsolete\n", 60015953580SDavid Woodhouse fd->ino, ref_offset(fd->raw))); 60115953580SDavid Woodhouse jffs2_mark_node_obsolete(c, fd->raw); 60215953580SDavid Woodhouse /* We don't want to remove it from the list immediately, 60315953580SDavid Woodhouse because that screws up getdents()/seek() semantics even 60415953580SDavid Woodhouse more than they're screwed already. Turn it into a 60515953580SDavid Woodhouse node-less deletion dirent instead -- a placeholder */ 60615953580SDavid Woodhouse fd->raw = NULL; 60715953580SDavid Woodhouse fd->ino = 0; 6081da177e4SLinus Torvalds break; 6091da177e4SLinus Torvalds } 6101da177e4SLinus Torvalds } 611ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 6121da177e4SLinus Torvalds } 6131da177e4SLinus Torvalds 6141da177e4SLinus Torvalds /* dead_f is NULL if this was a rename not a real unlink */ 6151da177e4SLinus Torvalds /* Also catch the !f->inocache case, where there was a dirent 6161da177e4SLinus Torvalds pointing to an inode which didn't exist. */ 6171da177e4SLinus Torvalds if (dead_f && dead_f->inocache) { 6181da177e4SLinus Torvalds 619ced22070SDavid Woodhouse mutex_lock(&dead_f->sem); 6201da177e4SLinus Torvalds 62132f1a95dSArtem B. Bityuckiy if (S_ISDIR(OFNI_EDONI_2SFFJ(dead_f)->i_mode)) { 6221da177e4SLinus Torvalds while (dead_f->dents) { 6231da177e4SLinus Torvalds /* There can be only deleted ones */ 6241da177e4SLinus Torvalds fd = dead_f->dents; 6251da177e4SLinus Torvalds 6261da177e4SLinus Torvalds dead_f->dents = fd->next; 6271da177e4SLinus Torvalds 6281da177e4SLinus Torvalds if (fd->ino) { 6291da177e4SLinus Torvalds printk(KERN_WARNING "Deleting inode #%u with active dentry \"%s\"->ino #%u\n", 6301da177e4SLinus Torvalds dead_f->inocache->ino, fd->name, fd->ino); 6311da177e4SLinus Torvalds } else { 63232f1a95dSArtem B. Bityuckiy D1(printk(KERN_DEBUG "Removing deletion dirent for \"%s\" from dir ino #%u\n", 63332f1a95dSArtem B. Bityuckiy fd->name, dead_f->inocache->ino)); 6341da177e4SLinus Torvalds } 63515953580SDavid Woodhouse if (fd->raw) 6361da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, fd->raw); 6371da177e4SLinus Torvalds jffs2_free_full_dirent(fd); 6381da177e4SLinus Torvalds } 63927c72b04SDavid Woodhouse dead_f->inocache->pino_nlink = 0; 64027c72b04SDavid Woodhouse } else 64127c72b04SDavid Woodhouse dead_f->inocache->pino_nlink--; 6421da177e4SLinus Torvalds /* NB: Caller must set inode nlink if appropriate */ 643ced22070SDavid Woodhouse mutex_unlock(&dead_f->sem); 6441da177e4SLinus Torvalds } 6451da177e4SLinus Torvalds 6461da177e4SLinus Torvalds jffs2_complete_reservation(c); 6471da177e4SLinus Torvalds 6481da177e4SLinus Torvalds return 0; 6491da177e4SLinus Torvalds } 6501da177e4SLinus Torvalds 6511da177e4SLinus Torvalds 6523a69e0cdSArtem 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) 6531da177e4SLinus Torvalds { 6541da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 6551da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 6569fe4854cSDavid Woodhouse uint32_t alloclen; 6571da177e4SLinus Torvalds int ret; 6581da177e4SLinus Torvalds 6591da177e4SLinus Torvalds rd = jffs2_alloc_raw_dirent(); 6601da177e4SLinus Torvalds if (!rd) 6611da177e4SLinus Torvalds return -ENOMEM; 6621da177e4SLinus Torvalds 6639fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 664e631ddbaSFerenc Havasi ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 6651da177e4SLinus Torvalds if (ret) { 6661da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 6671da177e4SLinus Torvalds return ret; 6681da177e4SLinus Torvalds } 6691da177e4SLinus Torvalds 670ced22070SDavid Woodhouse mutex_lock(&dir_f->sem); 6711da177e4SLinus Torvalds 6721da177e4SLinus Torvalds /* Build a deletion node */ 6731da177e4SLinus Torvalds rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 6741da177e4SLinus Torvalds rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 6751da177e4SLinus Torvalds rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 6761da177e4SLinus Torvalds rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 6771da177e4SLinus Torvalds 6781da177e4SLinus Torvalds rd->pino = cpu_to_je32(dir_f->inocache->ino); 6791da177e4SLinus Torvalds rd->version = cpu_to_je32(++dir_f->highest_version); 6801da177e4SLinus Torvalds rd->ino = cpu_to_je32(ino); 6813a69e0cdSArtem B. Bityutskiy rd->mctime = cpu_to_je32(time); 6821da177e4SLinus Torvalds rd->nsize = namelen; 6831da177e4SLinus Torvalds 6841da177e4SLinus Torvalds rd->type = type; 6851da177e4SLinus Torvalds 6861da177e4SLinus Torvalds rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 6871da177e4SLinus Torvalds rd->name_crc = cpu_to_je32(crc32(0, name, namelen)); 6881da177e4SLinus Torvalds 6899fe4854cSDavid Woodhouse fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL); 6901da177e4SLinus Torvalds 6911da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 6921da177e4SLinus Torvalds 6931da177e4SLinus Torvalds if (IS_ERR(fd)) { 6941da177e4SLinus Torvalds jffs2_complete_reservation(c); 695ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 6961da177e4SLinus Torvalds return PTR_ERR(fd); 6971da177e4SLinus Torvalds } 6981da177e4SLinus Torvalds 6991da177e4SLinus Torvalds /* File it. This will mark the old one obsolete. */ 7001da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &dir_f->dents); 7011da177e4SLinus Torvalds 7021da177e4SLinus Torvalds jffs2_complete_reservation(c); 703ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 7041da177e4SLinus Torvalds 7051da177e4SLinus Torvalds return 0; 7061da177e4SLinus Torvalds } 707