11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * JFFS2 -- Journalling Flash File System, Version 2. 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Copyright (C) 2001-2003 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 * 10182ec4eeSThomas Gleixner * $Id: write.c,v 1.97 2005/11/07 11:14:42 gleixner Exp $ 111da177e4SLinus Torvalds * 121da177e4SLinus Torvalds */ 131da177e4SLinus Torvalds 141da177e4SLinus Torvalds #include <linux/kernel.h> 151da177e4SLinus Torvalds #include <linux/fs.h> 161da177e4SLinus Torvalds #include <linux/crc32.h> 171da177e4SLinus Torvalds #include <linux/slab.h> 181da177e4SLinus Torvalds #include <linux/pagemap.h> 191da177e4SLinus Torvalds #include <linux/mtd/mtd.h> 201da177e4SLinus Torvalds #include "nodelist.h" 211da177e4SLinus Torvalds #include "compr.h" 221da177e4SLinus Torvalds 231da177e4SLinus Torvalds 241da177e4SLinus Torvalds int jffs2_do_new_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, uint32_t mode, struct jffs2_raw_inode *ri) 251da177e4SLinus Torvalds { 261da177e4SLinus Torvalds struct jffs2_inode_cache *ic; 271da177e4SLinus Torvalds 281da177e4SLinus Torvalds ic = jffs2_alloc_inode_cache(); 291da177e4SLinus Torvalds if (!ic) { 301da177e4SLinus Torvalds return -ENOMEM; 311da177e4SLinus Torvalds } 321da177e4SLinus Torvalds 331da177e4SLinus Torvalds memset(ic, 0, sizeof(*ic)); 341da177e4SLinus Torvalds 351da177e4SLinus Torvalds f->inocache = ic; 361da177e4SLinus Torvalds f->inocache->nlink = 1; 371da177e4SLinus Torvalds f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache; 381da177e4SLinus Torvalds f->inocache->state = INO_STATE_PRESENT; 391da177e4SLinus Torvalds 401da177e4SLinus Torvalds jffs2_add_ino_cache(c, f->inocache); 417d200960SDavid Woodhouse D1(printk(KERN_DEBUG "jffs2_do_new_inode(): Assigned ino# %d\n", f->inocache->ino)); 427d200960SDavid Woodhouse ri->ino = cpu_to_je32(f->inocache->ino); 431da177e4SLinus Torvalds 441da177e4SLinus Torvalds ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 451da177e4SLinus Torvalds ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE); 461da177e4SLinus Torvalds ri->totlen = cpu_to_je32(PAD(sizeof(*ri))); 471da177e4SLinus Torvalds ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 481da177e4SLinus Torvalds ri->mode = cpu_to_jemode(mode); 491da177e4SLinus Torvalds 501da177e4SLinus Torvalds f->highest_version = 1; 511da177e4SLinus Torvalds ri->version = cpu_to_je32(f->highest_version); 521da177e4SLinus Torvalds 531da177e4SLinus Torvalds return 0; 541da177e4SLinus Torvalds } 551da177e4SLinus Torvalds 561da177e4SLinus Torvalds /* jffs2_write_dnode - given a raw_inode, allocate a full_dnode for it, 571da177e4SLinus Torvalds write it to the flash, link it into the existing inode/fragment list */ 581da177e4SLinus Torvalds 599fe4854cSDavid Woodhouse struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 609fe4854cSDavid Woodhouse struct jffs2_raw_inode *ri, const unsigned char *data, 619fe4854cSDavid Woodhouse uint32_t datalen, int alloc_mode) 621da177e4SLinus Torvalds 631da177e4SLinus Torvalds { 641da177e4SLinus Torvalds struct jffs2_full_dnode *fn; 651da177e4SLinus Torvalds size_t retlen; 669fe4854cSDavid Woodhouse uint32_t flash_ofs; 671da177e4SLinus Torvalds struct kvec vecs[2]; 681da177e4SLinus Torvalds int ret; 691da177e4SLinus Torvalds int retried = 0; 701da177e4SLinus Torvalds unsigned long cnt = 2; 711da177e4SLinus Torvalds 721da177e4SLinus Torvalds D1(if(je32_to_cpu(ri->hdr_crc) != crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)) { 731da177e4SLinus Torvalds printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dnode()\n"); 741da177e4SLinus Torvalds BUG(); 751da177e4SLinus Torvalds } 761da177e4SLinus Torvalds ); 771da177e4SLinus Torvalds vecs[0].iov_base = ri; 781da177e4SLinus Torvalds vecs[0].iov_len = sizeof(*ri); 791da177e4SLinus Torvalds vecs[1].iov_base = (unsigned char *)data; 801da177e4SLinus Torvalds vecs[1].iov_len = datalen; 811da177e4SLinus Torvalds 821da177e4SLinus Torvalds if (je32_to_cpu(ri->totlen) != sizeof(*ri) + datalen) { 831da177e4SLinus 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); 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); 1009b88f473SEstelle Hammache D1(printk(KERN_DEBUG "jffs2_write_dnode : dnode_version %d, " 1019b88f473SEstelle Hammache "highest version %d -> updating dnode\n", 102e4803c30SEstelle Hammache 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)) { 1111da177e4SLinus Torvalds printk(KERN_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 { 1232f785402SDavid Woodhouse printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", flash_ofs); 1241da177e4SLinus Torvalds } 1252f785402SDavid Woodhouse if (!retried && alloc_mode != ALLOC_NORETRY) { 1261da177e4SLinus Torvalds /* Try to reallocate space and retry */ 1271da177e4SLinus Torvalds uint32_t dummy; 1281da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size]; 1291da177e4SLinus Torvalds 1301da177e4SLinus Torvalds retried = 1; 1311da177e4SLinus Torvalds 1321da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Retrying failed write.\n")); 1331da177e4SLinus Torvalds 134730554d9SArtem B. Bityutskiy jffs2_dbg_acct_sanity_check(c,jeb); 135730554d9SArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check(c, jeb); 1361da177e4SLinus Torvalds 1371da177e4SLinus Torvalds if (alloc_mode == ALLOC_GC) { 1389fe4854cSDavid Woodhouse ret = jffs2_reserve_space_gc(c, sizeof(*ri) + datalen, &dummy, 1399fe4854cSDavid Woodhouse JFFS2_SUMMARY_INODE_SIZE); 1401da177e4SLinus Torvalds } else { 1411da177e4SLinus Torvalds /* Locking pain */ 1421da177e4SLinus Torvalds up(&f->sem); 1431da177e4SLinus Torvalds jffs2_complete_reservation(c); 1441da177e4SLinus Torvalds 1459fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*ri) + datalen, &dummy, 1469fe4854cSDavid Woodhouse alloc_mode, JFFS2_SUMMARY_INODE_SIZE); 1471da177e4SLinus Torvalds down(&f->sem); 1481da177e4SLinus Torvalds } 1491da177e4SLinus Torvalds 1501da177e4SLinus Torvalds if (!ret) { 1519fe4854cSDavid Woodhouse flash_ofs = write_ofs(c); 1521da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs)); 1531da177e4SLinus Torvalds 154730554d9SArtem B. Bityutskiy jffs2_dbg_acct_sanity_check(c,jeb); 155730554d9SArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check(c, jeb); 1561da177e4SLinus Torvalds 1571da177e4SLinus Torvalds goto retry; 1581da177e4SLinus Torvalds } 1591da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret)); 1601da177e4SLinus Torvalds } 1611da177e4SLinus Torvalds /* Release the full_dnode which is now useless, and return */ 1621da177e4SLinus Torvalds jffs2_free_full_dnode(fn); 1631da177e4SLinus Torvalds return ERR_PTR(ret?ret:-EIO); 1641da177e4SLinus Torvalds } 1651da177e4SLinus Torvalds /* Mark the space used */ 1661da177e4SLinus Torvalds /* If node covers at least a whole page, or if it starts at the 1671da177e4SLinus Torvalds beginning of a page and runs to the end of the file, or if 1681da177e4SLinus Torvalds it's a hole node, mark it REF_PRISTINE, else REF_NORMAL. 1691da177e4SLinus Torvalds */ 1701da177e4SLinus Torvalds if ((je32_to_cpu(ri->dsize) >= PAGE_CACHE_SIZE) || 1711da177e4SLinus Torvalds ( ((je32_to_cpu(ri->offset)&(PAGE_CACHE_SIZE-1))==0) && 1721da177e4SLinus Torvalds (je32_to_cpu(ri->dsize)+je32_to_cpu(ri->offset) == je32_to_cpu(ri->isize)))) { 1732f785402SDavid Woodhouse flash_ofs |= REF_PRISTINE; 1741da177e4SLinus Torvalds } else { 1752f785402SDavid Woodhouse flash_ofs |= REF_NORMAL; 1761da177e4SLinus Torvalds } 1772f785402SDavid Woodhouse fn->raw = jffs2_add_physical_node_ref(c, flash_ofs, PAD(sizeof(*ri)+datalen), f->inocache); 1782f785402SDavid Woodhouse fn->ofs = je32_to_cpu(ri->offset); 1792f785402SDavid Woodhouse fn->size = je32_to_cpu(ri->dsize); 1802f785402SDavid Woodhouse fn->frags = 0; 1811da177e4SLinus Torvalds 1821da177e4SLinus 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", 1832f785402SDavid Woodhouse flash_ofs & ~3, flash_ofs & 3, je32_to_cpu(ri->dsize), 1841da177e4SLinus Torvalds je32_to_cpu(ri->csize), je32_to_cpu(ri->node_crc), 1851da177e4SLinus Torvalds je32_to_cpu(ri->data_crc), je32_to_cpu(ri->totlen))); 1861da177e4SLinus Torvalds 1871da177e4SLinus Torvalds if (retried) { 188730554d9SArtem B. Bityutskiy jffs2_dbg_acct_sanity_check(c,NULL); 1891da177e4SLinus Torvalds } 1901da177e4SLinus Torvalds 1911da177e4SLinus Torvalds return fn; 1921da177e4SLinus Torvalds } 1931da177e4SLinus Torvalds 1949fe4854cSDavid Woodhouse struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 1959fe4854cSDavid Woodhouse struct jffs2_raw_dirent *rd, const unsigned char *name, 1969fe4854cSDavid Woodhouse uint32_t namelen, int alloc_mode) 1971da177e4SLinus Torvalds { 1981da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 1991da177e4SLinus Torvalds size_t retlen; 2001da177e4SLinus Torvalds struct kvec vecs[2]; 2012f785402SDavid Woodhouse uint32_t flash_ofs; 2021da177e4SLinus Torvalds int retried = 0; 2031da177e4SLinus Torvalds int ret; 2041da177e4SLinus Torvalds 2051da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_write_dirent(ino #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x)\n", 2061da177e4SLinus Torvalds je32_to_cpu(rd->pino), name, name, je32_to_cpu(rd->ino), 2071da177e4SLinus Torvalds je32_to_cpu(rd->name_crc))); 208730554d9SArtem B. Bityutskiy 2091da177e4SLinus Torvalds D1(if(je32_to_cpu(rd->hdr_crc) != crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)) { 2101da177e4SLinus Torvalds printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dirent()\n"); 2111da177e4SLinus Torvalds BUG(); 2122f785402SDavid Woodhouse }); 2131da177e4SLinus Torvalds 2141da177e4SLinus Torvalds vecs[0].iov_base = rd; 2151da177e4SLinus Torvalds vecs[0].iov_len = sizeof(*rd); 2161da177e4SLinus Torvalds vecs[1].iov_base = (unsigned char *)name; 2171da177e4SLinus Torvalds vecs[1].iov_len = namelen; 2181da177e4SLinus Torvalds 2191da177e4SLinus Torvalds fd = jffs2_alloc_full_dirent(namelen+1); 2202f785402SDavid Woodhouse if (!fd) 2211da177e4SLinus Torvalds return ERR_PTR(-ENOMEM); 2221da177e4SLinus Torvalds 2231da177e4SLinus Torvalds fd->version = je32_to_cpu(rd->version); 2241da177e4SLinus Torvalds fd->ino = je32_to_cpu(rd->ino); 2251da177e4SLinus Torvalds fd->nhash = full_name_hash(name, strlen(name)); 2261da177e4SLinus Torvalds fd->type = rd->type; 2271da177e4SLinus Torvalds memcpy(fd->name, name, namelen); 2281da177e4SLinus Torvalds fd->name[namelen]=0; 2291da177e4SLinus Torvalds 2301da177e4SLinus Torvalds retry: 2312f785402SDavid Woodhouse flash_ofs = write_ofs(c); 2321da177e4SLinus Torvalds 2332f785402SDavid Woodhouse jffs2_dbg_prewrite_paranoia_check(c, flash_ofs, vecs[0].iov_len + vecs[1].iov_len); 2341da177e4SLinus Torvalds 2359b88f473SEstelle Hammache if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(rd->version) < f->highest_version)) { 2369b88f473SEstelle Hammache BUG_ON(!retried); 2379b88f473SEstelle Hammache D1(printk(KERN_DEBUG "jffs2_write_dirent : dirent_version %d, " 2389b88f473SEstelle Hammache "highest version %d -> updating dirent\n", 239e4803c30SEstelle Hammache je32_to_cpu(rd->version), f->highest_version)); 240e4803c30SEstelle Hammache rd->version = cpu_to_je32(++f->highest_version); 241e4803c30SEstelle Hammache fd->version = je32_to_cpu(rd->version); 242e4803c30SEstelle Hammache rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 243e4803c30SEstelle Hammache } 244e4803c30SEstelle Hammache 2451da177e4SLinus Torvalds ret = jffs2_flash_writev(c, vecs, 2, flash_ofs, &retlen, 2461da177e4SLinus Torvalds (alloc_mode==ALLOC_GC)?0:je32_to_cpu(rd->pino)); 2471da177e4SLinus Torvalds if (ret || (retlen != sizeof(*rd) + namelen)) { 2481da177e4SLinus Torvalds printk(KERN_NOTICE "Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n", 2491da177e4SLinus Torvalds sizeof(*rd)+namelen, flash_ofs, ret, retlen); 2501da177e4SLinus Torvalds /* Mark the space as dirtied */ 2511da177e4SLinus Torvalds if (retlen) { 2522f785402SDavid Woodhouse jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*rd)+namelen), NULL); 2531da177e4SLinus Torvalds } else { 2542f785402SDavid Woodhouse printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", flash_ofs); 2551da177e4SLinus Torvalds } 2562f785402SDavid Woodhouse if (!retried) { 2571da177e4SLinus Torvalds /* Try to reallocate space and retry */ 2581da177e4SLinus Torvalds uint32_t dummy; 2591da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size]; 2601da177e4SLinus Torvalds 2611da177e4SLinus Torvalds retried = 1; 2621da177e4SLinus Torvalds 2631da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Retrying failed write.\n")); 2641da177e4SLinus Torvalds 265730554d9SArtem B. Bityutskiy jffs2_dbg_acct_sanity_check(c,jeb); 266730554d9SArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check(c, jeb); 2671da177e4SLinus Torvalds 2681da177e4SLinus Torvalds if (alloc_mode == ALLOC_GC) { 2699fe4854cSDavid Woodhouse ret = jffs2_reserve_space_gc(c, sizeof(*rd) + namelen, &dummy, 2709fe4854cSDavid Woodhouse JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 2711da177e4SLinus Torvalds } else { 2721da177e4SLinus Torvalds /* Locking pain */ 2731da177e4SLinus Torvalds up(&f->sem); 2741da177e4SLinus Torvalds jffs2_complete_reservation(c); 2751da177e4SLinus Torvalds 2769fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*rd) + namelen, &dummy, 2779fe4854cSDavid Woodhouse alloc_mode, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 2781da177e4SLinus Torvalds down(&f->sem); 2791da177e4SLinus Torvalds } 2801da177e4SLinus Torvalds 2811da177e4SLinus Torvalds if (!ret) { 2829fe4854cSDavid Woodhouse flash_ofs = write_ofs(c); 2831da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs)); 284730554d9SArtem B. Bityutskiy jffs2_dbg_acct_sanity_check(c,jeb); 285730554d9SArtem B. Bityutskiy jffs2_dbg_acct_paranoia_check(c, jeb); 2861da177e4SLinus Torvalds goto retry; 2871da177e4SLinus Torvalds } 2881da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret)); 2891da177e4SLinus Torvalds } 2901da177e4SLinus Torvalds /* Release the full_dnode which is now useless, and return */ 2911da177e4SLinus Torvalds jffs2_free_full_dirent(fd); 2921da177e4SLinus Torvalds return ERR_PTR(ret?ret:-EIO); 2931da177e4SLinus Torvalds } 2941da177e4SLinus Torvalds /* Mark the space used */ 2952f785402SDavid Woodhouse fd->raw = jffs2_add_physical_node_ref(c, flash_ofs | REF_PRISTINE, PAD(sizeof(*rd)+namelen), f->inocache); 2961da177e4SLinus Torvalds 2971da177e4SLinus Torvalds if (retried) { 298730554d9SArtem B. Bityutskiy jffs2_dbg_acct_sanity_check(c,NULL); 2991da177e4SLinus Torvalds } 3001da177e4SLinus Torvalds 3011da177e4SLinus Torvalds return fd; 3021da177e4SLinus Torvalds } 3031da177e4SLinus Torvalds 3041da177e4SLinus Torvalds /* The OS-specific code fills in the metadata in the jffs2_raw_inode for us, so that 3051da177e4SLinus Torvalds we don't have to go digging in struct inode or its equivalent. It should set: 3061da177e4SLinus Torvalds mode, uid, gid, (starting)isize, atime, ctime, mtime */ 3071da177e4SLinus Torvalds int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 3081da177e4SLinus Torvalds struct jffs2_raw_inode *ri, unsigned char *buf, 3091da177e4SLinus Torvalds uint32_t offset, uint32_t writelen, uint32_t *retlen) 3101da177e4SLinus Torvalds { 3111da177e4SLinus Torvalds int ret = 0; 3121da177e4SLinus Torvalds uint32_t writtenlen = 0; 3131da177e4SLinus Torvalds 3141da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_write_inode_range(): Ino #%u, ofs 0x%x, len 0x%x\n", 3151da177e4SLinus Torvalds f->inocache->ino, offset, writelen)); 3161da177e4SLinus Torvalds 3171da177e4SLinus Torvalds while(writelen) { 3181da177e4SLinus Torvalds struct jffs2_full_dnode *fn; 3191da177e4SLinus Torvalds unsigned char *comprbuf = NULL; 3201da177e4SLinus Torvalds uint16_t comprtype = JFFS2_COMPR_NONE; 3219fe4854cSDavid Woodhouse uint32_t alloclen; 3221da177e4SLinus Torvalds uint32_t datalen, cdatalen; 3231da177e4SLinus Torvalds int retried = 0; 3241da177e4SLinus Torvalds 3251da177e4SLinus Torvalds retry: 3261da177e4SLinus Torvalds D2(printk(KERN_DEBUG "jffs2_commit_write() loop: 0x%x to write to 0x%x\n", writelen, offset)); 3271da177e4SLinus Torvalds 3289fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN, 329e631ddbaSFerenc Havasi &alloclen, ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE); 3301da177e4SLinus Torvalds if (ret) { 3311da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_reserve_space returned %d\n", ret)); 3321da177e4SLinus Torvalds break; 3331da177e4SLinus Torvalds } 3341da177e4SLinus Torvalds down(&f->sem); 3351da177e4SLinus Torvalds datalen = min_t(uint32_t, writelen, PAGE_CACHE_SIZE - (offset & (PAGE_CACHE_SIZE-1))); 3361da177e4SLinus Torvalds cdatalen = min_t(uint32_t, alloclen - sizeof(*ri), datalen); 3371da177e4SLinus Torvalds 3381da177e4SLinus Torvalds comprtype = jffs2_compress(c, f, buf, &comprbuf, &datalen, &cdatalen); 3391da177e4SLinus Torvalds 3401da177e4SLinus Torvalds ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 3411da177e4SLinus Torvalds ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE); 3421da177e4SLinus Torvalds ri->totlen = cpu_to_je32(sizeof(*ri) + cdatalen); 3431da177e4SLinus Torvalds ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 3441da177e4SLinus Torvalds 3451da177e4SLinus Torvalds ri->ino = cpu_to_je32(f->inocache->ino); 3461da177e4SLinus Torvalds ri->version = cpu_to_je32(++f->highest_version); 3471da177e4SLinus Torvalds ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen)); 3481da177e4SLinus Torvalds ri->offset = cpu_to_je32(offset); 3491da177e4SLinus Torvalds ri->csize = cpu_to_je32(cdatalen); 3501da177e4SLinus Torvalds ri->dsize = cpu_to_je32(datalen); 3511da177e4SLinus Torvalds ri->compr = comprtype & 0xff; 3521da177e4SLinus Torvalds ri->usercompr = (comprtype >> 8 ) & 0xff; 3531da177e4SLinus Torvalds ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 3541da177e4SLinus Torvalds ri->data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen)); 3551da177e4SLinus Torvalds 3569fe4854cSDavid Woodhouse fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, ALLOC_NORETRY); 3571da177e4SLinus Torvalds 3581da177e4SLinus Torvalds jffs2_free_comprbuf(comprbuf, buf); 3591da177e4SLinus Torvalds 3601da177e4SLinus Torvalds if (IS_ERR(fn)) { 3611da177e4SLinus Torvalds ret = PTR_ERR(fn); 3621da177e4SLinus Torvalds up(&f->sem); 3631da177e4SLinus Torvalds jffs2_complete_reservation(c); 3641da177e4SLinus Torvalds if (!retried) { 3651da177e4SLinus Torvalds /* Write error to be retried */ 3661da177e4SLinus Torvalds retried = 1; 3671da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Retrying node write in jffs2_write_inode_range()\n")); 3681da177e4SLinus Torvalds goto retry; 3691da177e4SLinus Torvalds } 3701da177e4SLinus Torvalds break; 3711da177e4SLinus Torvalds } 3721da177e4SLinus Torvalds ret = jffs2_add_full_dnode_to_inode(c, f, fn); 3731da177e4SLinus Torvalds if (f->metadata) { 3741da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, f->metadata->raw); 3751da177e4SLinus Torvalds jffs2_free_full_dnode(f->metadata); 3761da177e4SLinus Torvalds f->metadata = NULL; 3771da177e4SLinus Torvalds } 3781da177e4SLinus Torvalds if (ret) { 3791da177e4SLinus Torvalds /* Eep */ 3801da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Eep. add_full_dnode_to_inode() failed in commit_write, returned %d\n", ret)); 3811da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, fn->raw); 3821da177e4SLinus Torvalds jffs2_free_full_dnode(fn); 3831da177e4SLinus Torvalds 3841da177e4SLinus Torvalds up(&f->sem); 3851da177e4SLinus Torvalds jffs2_complete_reservation(c); 3861da177e4SLinus Torvalds break; 3871da177e4SLinus Torvalds } 3881da177e4SLinus Torvalds up(&f->sem); 3891da177e4SLinus Torvalds jffs2_complete_reservation(c); 3901da177e4SLinus Torvalds if (!datalen) { 3911da177e4SLinus Torvalds printk(KERN_WARNING "Eep. We didn't actually write any data in jffs2_write_inode_range()\n"); 3921da177e4SLinus Torvalds ret = -EIO; 3931da177e4SLinus Torvalds break; 3941da177e4SLinus Torvalds } 3951da177e4SLinus Torvalds D1(printk(KERN_DEBUG "increasing writtenlen by %d\n", datalen)); 3961da177e4SLinus Torvalds writtenlen += datalen; 3971da177e4SLinus Torvalds offset += datalen; 3981da177e4SLinus Torvalds writelen -= datalen; 3991da177e4SLinus Torvalds buf += datalen; 4001da177e4SLinus Torvalds } 4011da177e4SLinus Torvalds *retlen = writtenlen; 4021da177e4SLinus Torvalds return ret; 4031da177e4SLinus Torvalds } 4041da177e4SLinus Torvalds 4051da177e4SLinus 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) 4061da177e4SLinus Torvalds { 4071da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 4081da177e4SLinus Torvalds struct jffs2_full_dnode *fn; 4091da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 4109fe4854cSDavid Woodhouse uint32_t alloclen; 4111da177e4SLinus Torvalds int ret; 4121da177e4SLinus Torvalds 4131da177e4SLinus Torvalds /* Try to reserve enough space for both node and dirent. 4141da177e4SLinus Torvalds * Just the node will do for now, though 4151da177e4SLinus Torvalds */ 4169fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL, 417e631ddbaSFerenc Havasi JFFS2_SUMMARY_INODE_SIZE); 4181da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_do_create(): reserved 0x%x bytes\n", alloclen)); 4191da177e4SLinus Torvalds if (ret) { 4201da177e4SLinus Torvalds up(&f->sem); 4211da177e4SLinus Torvalds return ret; 4221da177e4SLinus Torvalds } 4231da177e4SLinus Torvalds 4241da177e4SLinus Torvalds ri->data_crc = cpu_to_je32(0); 4251da177e4SLinus Torvalds ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 4261da177e4SLinus Torvalds 4279fe4854cSDavid Woodhouse fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL); 4281da177e4SLinus Torvalds 4291da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_do_create created file with mode 0x%x\n", 4301da177e4SLinus Torvalds jemode_to_cpu(ri->mode))); 4311da177e4SLinus Torvalds 4321da177e4SLinus Torvalds if (IS_ERR(fn)) { 4331da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_write_dnode() failed\n")); 4341da177e4SLinus Torvalds /* Eeek. Wave bye bye */ 4351da177e4SLinus Torvalds up(&f->sem); 4361da177e4SLinus Torvalds jffs2_complete_reservation(c); 4371da177e4SLinus Torvalds return PTR_ERR(fn); 4381da177e4SLinus Torvalds } 4391da177e4SLinus Torvalds /* No data here. Only a metadata node, which will be 4401da177e4SLinus Torvalds obsoleted by the first data write 4411da177e4SLinus Torvalds */ 4421da177e4SLinus Torvalds f->metadata = fn; 4431da177e4SLinus Torvalds 4441da177e4SLinus Torvalds up(&f->sem); 4451da177e4SLinus Torvalds jffs2_complete_reservation(c); 4469fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 447e631ddbaSFerenc Havasi ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 4481da177e4SLinus Torvalds 4491da177e4SLinus Torvalds if (ret) { 4501da177e4SLinus Torvalds /* Eep. */ 4511da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_reserve_space() for dirent failed\n")); 4521da177e4SLinus Torvalds return ret; 4531da177e4SLinus Torvalds } 4541da177e4SLinus Torvalds 4551da177e4SLinus Torvalds rd = jffs2_alloc_raw_dirent(); 4561da177e4SLinus Torvalds if (!rd) { 4571da177e4SLinus Torvalds /* Argh. Now we treat it like a normal delete */ 4581da177e4SLinus Torvalds jffs2_complete_reservation(c); 4591da177e4SLinus Torvalds return -ENOMEM; 4601da177e4SLinus Torvalds } 4611da177e4SLinus Torvalds 4621da177e4SLinus Torvalds down(&dir_f->sem); 4631da177e4SLinus Torvalds 4641da177e4SLinus Torvalds rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 4651da177e4SLinus Torvalds rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 4661da177e4SLinus Torvalds rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 4671da177e4SLinus Torvalds rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 4681da177e4SLinus Torvalds 4691da177e4SLinus Torvalds rd->pino = cpu_to_je32(dir_f->inocache->ino); 4701da177e4SLinus Torvalds rd->version = cpu_to_je32(++dir_f->highest_version); 4711da177e4SLinus Torvalds rd->ino = ri->ino; 4721da177e4SLinus Torvalds rd->mctime = ri->ctime; 4731da177e4SLinus Torvalds rd->nsize = namelen; 4741da177e4SLinus Torvalds rd->type = DT_REG; 4751da177e4SLinus Torvalds rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 4761da177e4SLinus Torvalds rd->name_crc = cpu_to_je32(crc32(0, name, namelen)); 4771da177e4SLinus Torvalds 4789fe4854cSDavid Woodhouse fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL); 4791da177e4SLinus Torvalds 4801da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 4811da177e4SLinus Torvalds 4821da177e4SLinus Torvalds if (IS_ERR(fd)) { 4831da177e4SLinus Torvalds /* dirent failed to write. Delete the inode normally 4841da177e4SLinus Torvalds as if it were the final unlink() */ 4851da177e4SLinus Torvalds jffs2_complete_reservation(c); 4861da177e4SLinus Torvalds up(&dir_f->sem); 4871da177e4SLinus Torvalds return PTR_ERR(fd); 4881da177e4SLinus Torvalds } 4891da177e4SLinus Torvalds 4901da177e4SLinus Torvalds /* Link the fd into the inode's list, obsoleting an old 4911da177e4SLinus Torvalds one if necessary. */ 4921da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &dir_f->dents); 4931da177e4SLinus Torvalds 4941da177e4SLinus Torvalds jffs2_complete_reservation(c); 4951da177e4SLinus Torvalds up(&dir_f->sem); 4961da177e4SLinus Torvalds 4971da177e4SLinus Torvalds return 0; 4981da177e4SLinus Torvalds } 4991da177e4SLinus Torvalds 5001da177e4SLinus Torvalds 5011da177e4SLinus Torvalds int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, 5023a69e0cdSArtem B. Bityutskiy const char *name, int namelen, struct jffs2_inode_info *dead_f, 5033a69e0cdSArtem B. Bityutskiy uint32_t time) 5041da177e4SLinus Torvalds { 5051da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 5061da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 5079fe4854cSDavid Woodhouse uint32_t alloclen; 5081da177e4SLinus Torvalds int ret; 5091da177e4SLinus Torvalds 510a491486aSJoakim Tjernlund if (!jffs2_can_mark_obsolete(c)) { 5111da177e4SLinus Torvalds /* We can't mark stuff obsolete on the medium. We need to write a deletion dirent */ 5121da177e4SLinus Torvalds 5131da177e4SLinus Torvalds rd = jffs2_alloc_raw_dirent(); 5141da177e4SLinus Torvalds if (!rd) 5151da177e4SLinus Torvalds return -ENOMEM; 5161da177e4SLinus Torvalds 5179fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 518e631ddbaSFerenc Havasi ALLOC_DELETION, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 5191da177e4SLinus Torvalds if (ret) { 5201da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 5211da177e4SLinus Torvalds return ret; 5221da177e4SLinus Torvalds } 5231da177e4SLinus Torvalds 5241da177e4SLinus Torvalds down(&dir_f->sem); 5251da177e4SLinus Torvalds 5261da177e4SLinus Torvalds /* Build a deletion node */ 5271da177e4SLinus Torvalds rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 5281da177e4SLinus Torvalds rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 5291da177e4SLinus Torvalds rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 5301da177e4SLinus Torvalds rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 5311da177e4SLinus Torvalds 5321da177e4SLinus Torvalds rd->pino = cpu_to_je32(dir_f->inocache->ino); 5331da177e4SLinus Torvalds rd->version = cpu_to_je32(++dir_f->highest_version); 5341da177e4SLinus Torvalds rd->ino = cpu_to_je32(0); 5353a69e0cdSArtem B. Bityutskiy rd->mctime = cpu_to_je32(time); 5361da177e4SLinus Torvalds rd->nsize = namelen; 5371da177e4SLinus Torvalds rd->type = DT_UNKNOWN; 5381da177e4SLinus Torvalds rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 5391da177e4SLinus Torvalds rd->name_crc = cpu_to_je32(crc32(0, name, namelen)); 5401da177e4SLinus Torvalds 5419fe4854cSDavid Woodhouse fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_DELETION); 5421da177e4SLinus Torvalds 5431da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 5441da177e4SLinus Torvalds 5451da177e4SLinus Torvalds if (IS_ERR(fd)) { 5461da177e4SLinus Torvalds jffs2_complete_reservation(c); 5471da177e4SLinus Torvalds up(&dir_f->sem); 5481da177e4SLinus Torvalds return PTR_ERR(fd); 5491da177e4SLinus Torvalds } 5501da177e4SLinus Torvalds 5511da177e4SLinus Torvalds /* File it. This will mark the old one obsolete. */ 5521da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &dir_f->dents); 5531da177e4SLinus Torvalds up(&dir_f->sem); 5541da177e4SLinus Torvalds } else { 5551da177e4SLinus Torvalds struct jffs2_full_dirent **prev = &dir_f->dents; 5561da177e4SLinus Torvalds uint32_t nhash = full_name_hash(name, namelen); 5571da177e4SLinus Torvalds 5581da177e4SLinus Torvalds down(&dir_f->sem); 5591da177e4SLinus Torvalds 5601da177e4SLinus Torvalds while ((*prev) && (*prev)->nhash <= nhash) { 5611da177e4SLinus Torvalds if ((*prev)->nhash == nhash && 5621da177e4SLinus Torvalds !memcmp((*prev)->name, name, namelen) && 5631da177e4SLinus Torvalds !(*prev)->name[namelen]) { 5641da177e4SLinus Torvalds struct jffs2_full_dirent *this = *prev; 5651da177e4SLinus Torvalds 5661da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Marking old dirent node (ino #%u) @%08x obsolete\n", 5671da177e4SLinus Torvalds this->ino, ref_offset(this->raw))); 5681da177e4SLinus Torvalds 5691da177e4SLinus Torvalds *prev = this->next; 5701da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, (this->raw)); 5711da177e4SLinus Torvalds jffs2_free_full_dirent(this); 5721da177e4SLinus Torvalds break; 5731da177e4SLinus Torvalds } 5741da177e4SLinus Torvalds prev = &((*prev)->next); 5751da177e4SLinus Torvalds } 5761da177e4SLinus Torvalds up(&dir_f->sem); 5771da177e4SLinus Torvalds } 5781da177e4SLinus Torvalds 5791da177e4SLinus Torvalds /* dead_f is NULL if this was a rename not a real unlink */ 5801da177e4SLinus Torvalds /* Also catch the !f->inocache case, where there was a dirent 5811da177e4SLinus Torvalds pointing to an inode which didn't exist. */ 5821da177e4SLinus Torvalds if (dead_f && dead_f->inocache) { 5831da177e4SLinus Torvalds 5841da177e4SLinus Torvalds down(&dead_f->sem); 5851da177e4SLinus Torvalds 58632f1a95dSArtem B. Bityuckiy if (S_ISDIR(OFNI_EDONI_2SFFJ(dead_f)->i_mode)) { 5871da177e4SLinus Torvalds while (dead_f->dents) { 5881da177e4SLinus Torvalds /* There can be only deleted ones */ 5891da177e4SLinus Torvalds fd = dead_f->dents; 5901da177e4SLinus Torvalds 5911da177e4SLinus Torvalds dead_f->dents = fd->next; 5921da177e4SLinus Torvalds 5931da177e4SLinus Torvalds if (fd->ino) { 5941da177e4SLinus Torvalds printk(KERN_WARNING "Deleting inode #%u with active dentry \"%s\"->ino #%u\n", 5951da177e4SLinus Torvalds dead_f->inocache->ino, fd->name, fd->ino); 5961da177e4SLinus Torvalds } else { 59732f1a95dSArtem B. Bityuckiy D1(printk(KERN_DEBUG "Removing deletion dirent for \"%s\" from dir ino #%u\n", 59832f1a95dSArtem B. Bityuckiy fd->name, dead_f->inocache->ino)); 5991da177e4SLinus Torvalds } 6001da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, fd->raw); 6011da177e4SLinus Torvalds jffs2_free_full_dirent(fd); 6021da177e4SLinus Torvalds } 60332f1a95dSArtem B. Bityuckiy } 6041da177e4SLinus Torvalds 6051da177e4SLinus Torvalds dead_f->inocache->nlink--; 6061da177e4SLinus Torvalds /* NB: Caller must set inode nlink if appropriate */ 6071da177e4SLinus Torvalds up(&dead_f->sem); 6081da177e4SLinus Torvalds } 6091da177e4SLinus Torvalds 6101da177e4SLinus Torvalds jffs2_complete_reservation(c); 6111da177e4SLinus Torvalds 6121da177e4SLinus Torvalds return 0; 6131da177e4SLinus Torvalds } 6141da177e4SLinus Torvalds 6151da177e4SLinus Torvalds 6163a69e0cdSArtem 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) 6171da177e4SLinus Torvalds { 6181da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 6191da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 6209fe4854cSDavid Woodhouse uint32_t alloclen; 6211da177e4SLinus Torvalds int ret; 6221da177e4SLinus Torvalds 6231da177e4SLinus Torvalds rd = jffs2_alloc_raw_dirent(); 6241da177e4SLinus Torvalds if (!rd) 6251da177e4SLinus Torvalds return -ENOMEM; 6261da177e4SLinus Torvalds 6279fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 628e631ddbaSFerenc Havasi ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 6291da177e4SLinus Torvalds if (ret) { 6301da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 6311da177e4SLinus Torvalds return ret; 6321da177e4SLinus Torvalds } 6331da177e4SLinus Torvalds 6341da177e4SLinus Torvalds down(&dir_f->sem); 6351da177e4SLinus Torvalds 6361da177e4SLinus Torvalds /* Build a deletion node */ 6371da177e4SLinus Torvalds rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 6381da177e4SLinus Torvalds rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 6391da177e4SLinus Torvalds rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 6401da177e4SLinus Torvalds rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 6411da177e4SLinus Torvalds 6421da177e4SLinus Torvalds rd->pino = cpu_to_je32(dir_f->inocache->ino); 6431da177e4SLinus Torvalds rd->version = cpu_to_je32(++dir_f->highest_version); 6441da177e4SLinus Torvalds rd->ino = cpu_to_je32(ino); 6453a69e0cdSArtem B. Bityutskiy rd->mctime = cpu_to_je32(time); 6461da177e4SLinus Torvalds rd->nsize = namelen; 6471da177e4SLinus Torvalds 6481da177e4SLinus Torvalds rd->type = type; 6491da177e4SLinus Torvalds 6501da177e4SLinus Torvalds rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 6511da177e4SLinus Torvalds rd->name_crc = cpu_to_je32(crc32(0, name, namelen)); 6521da177e4SLinus Torvalds 6539fe4854cSDavid Woodhouse fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL); 6541da177e4SLinus Torvalds 6551da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 6561da177e4SLinus Torvalds 6571da177e4SLinus Torvalds if (IS_ERR(fd)) { 6581da177e4SLinus Torvalds jffs2_complete_reservation(c); 6591da177e4SLinus Torvalds up(&dir_f->sem); 6601da177e4SLinus Torvalds return PTR_ERR(fd); 6611da177e4SLinus Torvalds } 6621da177e4SLinus Torvalds 6631da177e4SLinus Torvalds /* File it. This will mark the old one obsolete. */ 6641da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &dir_f->dents); 6651da177e4SLinus Torvalds 6661da177e4SLinus Torvalds jffs2_complete_reservation(c); 6671da177e4SLinus Torvalds up(&dir_f->sem); 6681da177e4SLinus Torvalds 6691da177e4SLinus Torvalds return 0; 6701da177e4SLinus Torvalds } 671