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 * 10e4803c30SEstelle Hammache * $Id: write.c,v 1.88 2005/01/24 21:13:39 hammache 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->ino = ++c->highest_ino; 391da177e4SLinus Torvalds f->inocache->state = INO_STATE_PRESENT; 401da177e4SLinus Torvalds 411da177e4SLinus Torvalds ri->ino = cpu_to_je32(f->inocache->ino); 421da177e4SLinus Torvalds 431da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_do_new_inode(): Assigned ino# %d\n", f->inocache->ino)); 441da177e4SLinus Torvalds jffs2_add_ino_cache(c, f->inocache); 451da177e4SLinus Torvalds 461da177e4SLinus Torvalds ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 471da177e4SLinus Torvalds ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE); 481da177e4SLinus Torvalds ri->totlen = cpu_to_je32(PAD(sizeof(*ri))); 491da177e4SLinus Torvalds ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 501da177e4SLinus Torvalds ri->mode = cpu_to_jemode(mode); 511da177e4SLinus Torvalds 521da177e4SLinus Torvalds f->highest_version = 1; 531da177e4SLinus Torvalds ri->version = cpu_to_je32(f->highest_version); 541da177e4SLinus Torvalds 551da177e4SLinus Torvalds return 0; 561da177e4SLinus Torvalds } 571da177e4SLinus Torvalds 581da177e4SLinus Torvalds #if CONFIG_JFFS2_FS_DEBUG > 0 591da177e4SLinus Torvalds static void writecheck(struct jffs2_sb_info *c, uint32_t ofs) 601da177e4SLinus Torvalds { 611da177e4SLinus Torvalds unsigned char buf[16]; 621da177e4SLinus Torvalds size_t retlen; 631da177e4SLinus Torvalds int ret, i; 641da177e4SLinus Torvalds 651da177e4SLinus Torvalds ret = jffs2_flash_read(c, ofs, 16, &retlen, buf); 661da177e4SLinus Torvalds if (ret || (retlen != 16)) { 671da177e4SLinus Torvalds D1(printk(KERN_DEBUG "read failed or short in writecheck(). ret %d, retlen %zd\n", ret, retlen)); 681da177e4SLinus Torvalds return; 691da177e4SLinus Torvalds } 701da177e4SLinus Torvalds ret = 0; 711da177e4SLinus Torvalds for (i=0; i<16; i++) { 721da177e4SLinus Torvalds if (buf[i] != 0xff) 731da177e4SLinus Torvalds ret = 1; 741da177e4SLinus Torvalds } 751da177e4SLinus Torvalds if (ret) { 761da177e4SLinus Torvalds printk(KERN_WARNING "ARGH. About to write node to 0x%08x on flash, but there are data already there:\n", ofs); 771da177e4SLinus Torvalds printk(KERN_WARNING "0x%08x: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n", 781da177e4SLinus Torvalds ofs, 791da177e4SLinus Torvalds buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7], 801da177e4SLinus Torvalds buf[8], buf[9], buf[10], buf[11], buf[12], buf[13], buf[14], buf[15]); 811da177e4SLinus Torvalds } 821da177e4SLinus Torvalds } 831da177e4SLinus Torvalds #endif 841da177e4SLinus Torvalds 851da177e4SLinus Torvalds 861da177e4SLinus Torvalds /* jffs2_write_dnode - given a raw_inode, allocate a full_dnode for it, 871da177e4SLinus Torvalds write it to the flash, link it into the existing inode/fragment list */ 881da177e4SLinus Torvalds 891da177e4SLinus Torvalds struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, struct jffs2_raw_inode *ri, const unsigned char *data, uint32_t datalen, uint32_t flash_ofs, int alloc_mode) 901da177e4SLinus Torvalds 911da177e4SLinus Torvalds { 921da177e4SLinus Torvalds struct jffs2_raw_node_ref *raw; 931da177e4SLinus Torvalds struct jffs2_full_dnode *fn; 941da177e4SLinus Torvalds size_t retlen; 951da177e4SLinus Torvalds struct kvec vecs[2]; 961da177e4SLinus Torvalds int ret; 971da177e4SLinus Torvalds int retried = 0; 981da177e4SLinus Torvalds unsigned long cnt = 2; 991da177e4SLinus Torvalds 1001da177e4SLinus Torvalds D1(if(je32_to_cpu(ri->hdr_crc) != crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)) { 1011da177e4SLinus Torvalds printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dnode()\n"); 1021da177e4SLinus Torvalds BUG(); 1031da177e4SLinus Torvalds } 1041da177e4SLinus Torvalds ); 1051da177e4SLinus Torvalds vecs[0].iov_base = ri; 1061da177e4SLinus Torvalds vecs[0].iov_len = sizeof(*ri); 1071da177e4SLinus Torvalds vecs[1].iov_base = (unsigned char *)data; 1081da177e4SLinus Torvalds vecs[1].iov_len = datalen; 1091da177e4SLinus Torvalds 1101da177e4SLinus Torvalds D1(writecheck(c, flash_ofs)); 1111da177e4SLinus Torvalds 1121da177e4SLinus Torvalds if (je32_to_cpu(ri->totlen) != sizeof(*ri) + datalen) { 1131da177e4SLinus 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); 1141da177e4SLinus Torvalds } 1151da177e4SLinus Torvalds raw = jffs2_alloc_raw_node_ref(); 1161da177e4SLinus Torvalds if (!raw) 1171da177e4SLinus Torvalds return ERR_PTR(-ENOMEM); 1181da177e4SLinus Torvalds 1191da177e4SLinus Torvalds fn = jffs2_alloc_full_dnode(); 1201da177e4SLinus Torvalds if (!fn) { 1211da177e4SLinus Torvalds jffs2_free_raw_node_ref(raw); 1221da177e4SLinus Torvalds return ERR_PTR(-ENOMEM); 1231da177e4SLinus Torvalds } 1241da177e4SLinus Torvalds 1251da177e4SLinus Torvalds fn->ofs = je32_to_cpu(ri->offset); 1261da177e4SLinus Torvalds fn->size = je32_to_cpu(ri->dsize); 1271da177e4SLinus Torvalds fn->frags = 0; 1281da177e4SLinus Torvalds 1291da177e4SLinus Torvalds /* check number of valid vecs */ 1301da177e4SLinus Torvalds if (!datalen || !data) 1311da177e4SLinus Torvalds cnt = 1; 1321da177e4SLinus Torvalds retry: 1331da177e4SLinus Torvalds fn->raw = raw; 1341da177e4SLinus Torvalds 1351da177e4SLinus Torvalds raw->flash_offset = flash_ofs; 1361da177e4SLinus Torvalds raw->__totlen = PAD(sizeof(*ri)+datalen); 1371da177e4SLinus Torvalds raw->next_phys = NULL; 1381da177e4SLinus Torvalds 139e4803c30SEstelle Hammache if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(ri->version) < f->highest_version)) 140e4803c30SEstelle Hammache { 141e4803c30SEstelle Hammache if (! retried) 142e4803c30SEstelle Hammache { 143e4803c30SEstelle Hammache BUG(); 144e4803c30SEstelle Hammache } 145e4803c30SEstelle Hammache else 146e4803c30SEstelle Hammache { 147e4803c30SEstelle Hammache D1(printk(KERN_DEBUG "jffs2_write_dnode : dnode_version %d, highest version %d -> updating dnode\n", 148e4803c30SEstelle Hammache je32_to_cpu(ri->version), f->highest_version)); 149e4803c30SEstelle Hammache ri->version = cpu_to_je32(++f->highest_version); 150e4803c30SEstelle Hammache ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 151e4803c30SEstelle Hammache } 152e4803c30SEstelle Hammache } 153e4803c30SEstelle Hammache 1541da177e4SLinus Torvalds ret = jffs2_flash_writev(c, vecs, cnt, flash_ofs, &retlen, 1551da177e4SLinus Torvalds (alloc_mode==ALLOC_GC)?0:f->inocache->ino); 1561da177e4SLinus Torvalds 1571da177e4SLinus Torvalds if (ret || (retlen != sizeof(*ri) + datalen)) { 1581da177e4SLinus Torvalds printk(KERN_NOTICE "Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n", 1591da177e4SLinus Torvalds sizeof(*ri)+datalen, flash_ofs, ret, retlen); 1601da177e4SLinus Torvalds 1611da177e4SLinus Torvalds /* Mark the space as dirtied */ 1621da177e4SLinus Torvalds if (retlen) { 1631da177e4SLinus Torvalds /* Doesn't belong to any inode */ 1641da177e4SLinus Torvalds raw->next_in_ino = NULL; 1651da177e4SLinus Torvalds 1661da177e4SLinus Torvalds /* Don't change raw->size to match retlen. We may have 1671da177e4SLinus Torvalds written the node header already, and only the data will 1681da177e4SLinus Torvalds seem corrupted, in which case the scan would skip over 1691da177e4SLinus Torvalds any node we write before the original intended end of 1701da177e4SLinus Torvalds this node */ 1711da177e4SLinus Torvalds raw->flash_offset |= REF_OBSOLETE; 1721da177e4SLinus Torvalds jffs2_add_physical_node_ref(c, raw); 1731da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, raw); 1741da177e4SLinus Torvalds } else { 1751da177e4SLinus Torvalds printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", raw->flash_offset); 1761da177e4SLinus Torvalds jffs2_free_raw_node_ref(raw); 1771da177e4SLinus Torvalds } 1781da177e4SLinus Torvalds if (!retried && alloc_mode != ALLOC_NORETRY && (raw = jffs2_alloc_raw_node_ref())) { 1791da177e4SLinus Torvalds /* Try to reallocate space and retry */ 1801da177e4SLinus Torvalds uint32_t dummy; 1811da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size]; 1821da177e4SLinus Torvalds 1831da177e4SLinus Torvalds retried = 1; 1841da177e4SLinus Torvalds 1851da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Retrying failed write.\n")); 1861da177e4SLinus Torvalds 1871da177e4SLinus Torvalds ACCT_SANITY_CHECK(c,jeb); 1881da177e4SLinus Torvalds D1(ACCT_PARANOIA_CHECK(jeb)); 1891da177e4SLinus Torvalds 1901da177e4SLinus Torvalds if (alloc_mode == ALLOC_GC) { 1911da177e4SLinus Torvalds ret = jffs2_reserve_space_gc(c, sizeof(*ri) + datalen, &flash_ofs, &dummy); 1921da177e4SLinus Torvalds } else { 1931da177e4SLinus Torvalds /* Locking pain */ 1941da177e4SLinus Torvalds up(&f->sem); 1951da177e4SLinus Torvalds jffs2_complete_reservation(c); 1961da177e4SLinus Torvalds 1971da177e4SLinus Torvalds ret = jffs2_reserve_space(c, sizeof(*ri) + datalen, &flash_ofs, &dummy, alloc_mode); 1981da177e4SLinus Torvalds down(&f->sem); 1991da177e4SLinus Torvalds } 2001da177e4SLinus Torvalds 2011da177e4SLinus Torvalds if (!ret) { 2021da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs)); 2031da177e4SLinus Torvalds 2041da177e4SLinus Torvalds ACCT_SANITY_CHECK(c,jeb); 2051da177e4SLinus Torvalds D1(ACCT_PARANOIA_CHECK(jeb)); 2061da177e4SLinus Torvalds 2071da177e4SLinus Torvalds goto retry; 2081da177e4SLinus Torvalds } 2091da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret)); 2101da177e4SLinus Torvalds jffs2_free_raw_node_ref(raw); 2111da177e4SLinus Torvalds } 2121da177e4SLinus Torvalds /* Release the full_dnode which is now useless, and return */ 2131da177e4SLinus Torvalds jffs2_free_full_dnode(fn); 2141da177e4SLinus Torvalds return ERR_PTR(ret?ret:-EIO); 2151da177e4SLinus Torvalds } 2161da177e4SLinus Torvalds /* Mark the space used */ 2171da177e4SLinus Torvalds /* If node covers at least a whole page, or if it starts at the 2181da177e4SLinus Torvalds beginning of a page and runs to the end of the file, or if 2191da177e4SLinus Torvalds it's a hole node, mark it REF_PRISTINE, else REF_NORMAL. 2201da177e4SLinus Torvalds */ 2211da177e4SLinus Torvalds if ((je32_to_cpu(ri->dsize) >= PAGE_CACHE_SIZE) || 2221da177e4SLinus Torvalds ( ((je32_to_cpu(ri->offset)&(PAGE_CACHE_SIZE-1))==0) && 2231da177e4SLinus Torvalds (je32_to_cpu(ri->dsize)+je32_to_cpu(ri->offset) == je32_to_cpu(ri->isize)))) { 2241da177e4SLinus Torvalds raw->flash_offset |= REF_PRISTINE; 2251da177e4SLinus Torvalds } else { 2261da177e4SLinus Torvalds raw->flash_offset |= REF_NORMAL; 2271da177e4SLinus Torvalds } 2281da177e4SLinus Torvalds jffs2_add_physical_node_ref(c, raw); 2291da177e4SLinus Torvalds 2301da177e4SLinus Torvalds /* Link into per-inode list */ 2311da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 2321da177e4SLinus Torvalds raw->next_in_ino = f->inocache->nodes; 2331da177e4SLinus Torvalds f->inocache->nodes = raw; 2341da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 2351da177e4SLinus Torvalds 2361da177e4SLinus 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", 2371da177e4SLinus Torvalds flash_ofs, ref_flags(raw), je32_to_cpu(ri->dsize), 2381da177e4SLinus Torvalds je32_to_cpu(ri->csize), je32_to_cpu(ri->node_crc), 2391da177e4SLinus Torvalds je32_to_cpu(ri->data_crc), je32_to_cpu(ri->totlen))); 2401da177e4SLinus Torvalds 2411da177e4SLinus Torvalds if (retried) { 2421da177e4SLinus Torvalds ACCT_SANITY_CHECK(c,NULL); 2431da177e4SLinus Torvalds } 2441da177e4SLinus Torvalds 2451da177e4SLinus Torvalds return fn; 2461da177e4SLinus Torvalds } 2471da177e4SLinus Torvalds 2481da177e4SLinus Torvalds struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jffs2_inode_info *f, struct jffs2_raw_dirent *rd, const unsigned char *name, uint32_t namelen, uint32_t flash_ofs, int alloc_mode) 2491da177e4SLinus Torvalds { 2501da177e4SLinus Torvalds struct jffs2_raw_node_ref *raw; 2511da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 2521da177e4SLinus Torvalds size_t retlen; 2531da177e4SLinus Torvalds struct kvec vecs[2]; 2541da177e4SLinus Torvalds int retried = 0; 2551da177e4SLinus Torvalds int ret; 2561da177e4SLinus Torvalds 2571da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_write_dirent(ino #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x)\n", 2581da177e4SLinus Torvalds je32_to_cpu(rd->pino), name, name, je32_to_cpu(rd->ino), 2591da177e4SLinus Torvalds je32_to_cpu(rd->name_crc))); 2601da177e4SLinus Torvalds D1(writecheck(c, flash_ofs)); 2611da177e4SLinus Torvalds 2621da177e4SLinus Torvalds D1(if(je32_to_cpu(rd->hdr_crc) != crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)) { 2631da177e4SLinus Torvalds printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dirent()\n"); 2641da177e4SLinus Torvalds BUG(); 2651da177e4SLinus Torvalds } 2661da177e4SLinus Torvalds ); 2671da177e4SLinus Torvalds 2681da177e4SLinus Torvalds vecs[0].iov_base = rd; 2691da177e4SLinus Torvalds vecs[0].iov_len = sizeof(*rd); 2701da177e4SLinus Torvalds vecs[1].iov_base = (unsigned char *)name; 2711da177e4SLinus Torvalds vecs[1].iov_len = namelen; 2721da177e4SLinus Torvalds 2731da177e4SLinus Torvalds raw = jffs2_alloc_raw_node_ref(); 2741da177e4SLinus Torvalds 2751da177e4SLinus Torvalds if (!raw) 2761da177e4SLinus Torvalds return ERR_PTR(-ENOMEM); 2771da177e4SLinus Torvalds 2781da177e4SLinus Torvalds fd = jffs2_alloc_full_dirent(namelen+1); 2791da177e4SLinus Torvalds if (!fd) { 2801da177e4SLinus Torvalds jffs2_free_raw_node_ref(raw); 2811da177e4SLinus Torvalds return ERR_PTR(-ENOMEM); 2821da177e4SLinus Torvalds } 2831da177e4SLinus Torvalds 2841da177e4SLinus Torvalds fd->version = je32_to_cpu(rd->version); 2851da177e4SLinus Torvalds fd->ino = je32_to_cpu(rd->ino); 2861da177e4SLinus Torvalds fd->nhash = full_name_hash(name, strlen(name)); 2871da177e4SLinus Torvalds fd->type = rd->type; 2881da177e4SLinus Torvalds memcpy(fd->name, name, namelen); 2891da177e4SLinus Torvalds fd->name[namelen]=0; 2901da177e4SLinus Torvalds 2911da177e4SLinus Torvalds retry: 2921da177e4SLinus Torvalds fd->raw = raw; 2931da177e4SLinus Torvalds 2941da177e4SLinus Torvalds raw->flash_offset = flash_ofs; 2951da177e4SLinus Torvalds raw->__totlen = PAD(sizeof(*rd)+namelen); 2961da177e4SLinus Torvalds raw->next_phys = NULL; 2971da177e4SLinus Torvalds 298e4803c30SEstelle Hammache if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(rd->version) < f->highest_version)) 299e4803c30SEstelle Hammache { 300e4803c30SEstelle Hammache if (! retried) 301e4803c30SEstelle Hammache { 302e4803c30SEstelle Hammache BUG(); 303e4803c30SEstelle Hammache } 304e4803c30SEstelle Hammache else 305e4803c30SEstelle Hammache { 306e4803c30SEstelle Hammache D1(printk(KERN_DEBUG "jffs2_write_dirent : dirent_version %d, highest version %d -> updating dirent\n", 307e4803c30SEstelle Hammache je32_to_cpu(rd->version), f->highest_version)); 308e4803c30SEstelle Hammache rd->version = cpu_to_je32(++f->highest_version); 309e4803c30SEstelle Hammache fd->version = je32_to_cpu(rd->version); 310e4803c30SEstelle Hammache rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 311e4803c30SEstelle Hammache } 312e4803c30SEstelle Hammache } 313e4803c30SEstelle Hammache 3141da177e4SLinus Torvalds ret = jffs2_flash_writev(c, vecs, 2, flash_ofs, &retlen, 3151da177e4SLinus Torvalds (alloc_mode==ALLOC_GC)?0:je32_to_cpu(rd->pino)); 3161da177e4SLinus Torvalds if (ret || (retlen != sizeof(*rd) + namelen)) { 3171da177e4SLinus Torvalds printk(KERN_NOTICE "Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n", 3181da177e4SLinus Torvalds sizeof(*rd)+namelen, flash_ofs, ret, retlen); 3191da177e4SLinus Torvalds /* Mark the space as dirtied */ 3201da177e4SLinus Torvalds if (retlen) { 3211da177e4SLinus Torvalds raw->next_in_ino = NULL; 3221da177e4SLinus Torvalds raw->flash_offset |= REF_OBSOLETE; 3231da177e4SLinus Torvalds jffs2_add_physical_node_ref(c, raw); 3241da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, raw); 3251da177e4SLinus Torvalds } else { 3261da177e4SLinus Torvalds printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", raw->flash_offset); 3271da177e4SLinus Torvalds jffs2_free_raw_node_ref(raw); 3281da177e4SLinus Torvalds } 3291da177e4SLinus Torvalds if (!retried && (raw = jffs2_alloc_raw_node_ref())) { 3301da177e4SLinus Torvalds /* Try to reallocate space and retry */ 3311da177e4SLinus Torvalds uint32_t dummy; 3321da177e4SLinus Torvalds struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size]; 3331da177e4SLinus Torvalds 3341da177e4SLinus Torvalds retried = 1; 3351da177e4SLinus Torvalds 3361da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Retrying failed write.\n")); 3371da177e4SLinus Torvalds 3381da177e4SLinus Torvalds ACCT_SANITY_CHECK(c,jeb); 3391da177e4SLinus Torvalds D1(ACCT_PARANOIA_CHECK(jeb)); 3401da177e4SLinus Torvalds 3411da177e4SLinus Torvalds if (alloc_mode == ALLOC_GC) { 3421da177e4SLinus Torvalds ret = jffs2_reserve_space_gc(c, sizeof(*rd) + namelen, &flash_ofs, &dummy); 3431da177e4SLinus Torvalds } else { 3441da177e4SLinus Torvalds /* Locking pain */ 3451da177e4SLinus Torvalds up(&f->sem); 3461da177e4SLinus Torvalds jffs2_complete_reservation(c); 3471da177e4SLinus Torvalds 3481da177e4SLinus Torvalds ret = jffs2_reserve_space(c, sizeof(*rd) + namelen, &flash_ofs, &dummy, alloc_mode); 3491da177e4SLinus Torvalds down(&f->sem); 3501da177e4SLinus Torvalds } 3511da177e4SLinus Torvalds 3521da177e4SLinus Torvalds if (!ret) { 3531da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs)); 3541da177e4SLinus Torvalds ACCT_SANITY_CHECK(c,jeb); 3551da177e4SLinus Torvalds D1(ACCT_PARANOIA_CHECK(jeb)); 3561da177e4SLinus Torvalds goto retry; 3571da177e4SLinus Torvalds } 3581da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret)); 3591da177e4SLinus Torvalds jffs2_free_raw_node_ref(raw); 3601da177e4SLinus Torvalds } 3611da177e4SLinus Torvalds /* Release the full_dnode which is now useless, and return */ 3621da177e4SLinus Torvalds jffs2_free_full_dirent(fd); 3631da177e4SLinus Torvalds return ERR_PTR(ret?ret:-EIO); 3641da177e4SLinus Torvalds } 3651da177e4SLinus Torvalds /* Mark the space used */ 3661da177e4SLinus Torvalds raw->flash_offset |= REF_PRISTINE; 3671da177e4SLinus Torvalds jffs2_add_physical_node_ref(c, raw); 3681da177e4SLinus Torvalds 3691da177e4SLinus Torvalds spin_lock(&c->erase_completion_lock); 3701da177e4SLinus Torvalds raw->next_in_ino = f->inocache->nodes; 3711da177e4SLinus Torvalds f->inocache->nodes = raw; 3721da177e4SLinus Torvalds spin_unlock(&c->erase_completion_lock); 3731da177e4SLinus Torvalds 3741da177e4SLinus Torvalds if (retried) { 3751da177e4SLinus Torvalds ACCT_SANITY_CHECK(c,NULL); 3761da177e4SLinus Torvalds } 3771da177e4SLinus Torvalds 3781da177e4SLinus Torvalds return fd; 3791da177e4SLinus Torvalds } 3801da177e4SLinus Torvalds 3811da177e4SLinus Torvalds /* The OS-specific code fills in the metadata in the jffs2_raw_inode for us, so that 3821da177e4SLinus Torvalds we don't have to go digging in struct inode or its equivalent. It should set: 3831da177e4SLinus Torvalds mode, uid, gid, (starting)isize, atime, ctime, mtime */ 3841da177e4SLinus Torvalds int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 3851da177e4SLinus Torvalds struct jffs2_raw_inode *ri, unsigned char *buf, 3861da177e4SLinus Torvalds uint32_t offset, uint32_t writelen, uint32_t *retlen) 3871da177e4SLinus Torvalds { 3881da177e4SLinus Torvalds int ret = 0; 3891da177e4SLinus Torvalds uint32_t writtenlen = 0; 3901da177e4SLinus Torvalds 3911da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_write_inode_range(): Ino #%u, ofs 0x%x, len 0x%x\n", 3921da177e4SLinus Torvalds f->inocache->ino, offset, writelen)); 3931da177e4SLinus Torvalds 3941da177e4SLinus Torvalds while(writelen) { 3951da177e4SLinus Torvalds struct jffs2_full_dnode *fn; 3961da177e4SLinus Torvalds unsigned char *comprbuf = NULL; 3971da177e4SLinus Torvalds uint16_t comprtype = JFFS2_COMPR_NONE; 3981da177e4SLinus Torvalds uint32_t phys_ofs, alloclen; 3991da177e4SLinus Torvalds uint32_t datalen, cdatalen; 4001da177e4SLinus Torvalds int retried = 0; 4011da177e4SLinus Torvalds 4021da177e4SLinus Torvalds retry: 4031da177e4SLinus Torvalds D2(printk(KERN_DEBUG "jffs2_commit_write() loop: 0x%x to write to 0x%x\n", writelen, offset)); 4041da177e4SLinus Torvalds 4051da177e4SLinus Torvalds ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN, &phys_ofs, &alloclen, ALLOC_NORMAL); 4061da177e4SLinus Torvalds if (ret) { 4071da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_reserve_space returned %d\n", ret)); 4081da177e4SLinus Torvalds break; 4091da177e4SLinus Torvalds } 4101da177e4SLinus Torvalds down(&f->sem); 4111da177e4SLinus Torvalds datalen = min_t(uint32_t, writelen, PAGE_CACHE_SIZE - (offset & (PAGE_CACHE_SIZE-1))); 4121da177e4SLinus Torvalds cdatalen = min_t(uint32_t, alloclen - sizeof(*ri), datalen); 4131da177e4SLinus Torvalds 4141da177e4SLinus Torvalds comprtype = jffs2_compress(c, f, buf, &comprbuf, &datalen, &cdatalen); 4151da177e4SLinus Torvalds 4161da177e4SLinus Torvalds ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 4171da177e4SLinus Torvalds ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE); 4181da177e4SLinus Torvalds ri->totlen = cpu_to_je32(sizeof(*ri) + cdatalen); 4191da177e4SLinus Torvalds ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 4201da177e4SLinus Torvalds 4211da177e4SLinus Torvalds ri->ino = cpu_to_je32(f->inocache->ino); 4221da177e4SLinus Torvalds ri->version = cpu_to_je32(++f->highest_version); 4231da177e4SLinus Torvalds ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen)); 4241da177e4SLinus Torvalds ri->offset = cpu_to_je32(offset); 4251da177e4SLinus Torvalds ri->csize = cpu_to_je32(cdatalen); 4261da177e4SLinus Torvalds ri->dsize = cpu_to_je32(datalen); 4271da177e4SLinus Torvalds ri->compr = comprtype & 0xff; 4281da177e4SLinus Torvalds ri->usercompr = (comprtype >> 8 ) & 0xff; 4291da177e4SLinus Torvalds ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 4301da177e4SLinus Torvalds ri->data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen)); 4311da177e4SLinus Torvalds 4321da177e4SLinus Torvalds fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, phys_ofs, ALLOC_NORETRY); 4331da177e4SLinus Torvalds 4341da177e4SLinus Torvalds jffs2_free_comprbuf(comprbuf, buf); 4351da177e4SLinus Torvalds 4361da177e4SLinus Torvalds if (IS_ERR(fn)) { 4371da177e4SLinus Torvalds ret = PTR_ERR(fn); 4381da177e4SLinus Torvalds up(&f->sem); 4391da177e4SLinus Torvalds jffs2_complete_reservation(c); 4401da177e4SLinus Torvalds if (!retried) { 4411da177e4SLinus Torvalds /* Write error to be retried */ 4421da177e4SLinus Torvalds retried = 1; 4431da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Retrying node write in jffs2_write_inode_range()\n")); 4441da177e4SLinus Torvalds goto retry; 4451da177e4SLinus Torvalds } 4461da177e4SLinus Torvalds break; 4471da177e4SLinus Torvalds } 4481da177e4SLinus Torvalds ret = jffs2_add_full_dnode_to_inode(c, f, fn); 4491da177e4SLinus Torvalds if (f->metadata) { 4501da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, f->metadata->raw); 4511da177e4SLinus Torvalds jffs2_free_full_dnode(f->metadata); 4521da177e4SLinus Torvalds f->metadata = NULL; 4531da177e4SLinus Torvalds } 4541da177e4SLinus Torvalds if (ret) { 4551da177e4SLinus Torvalds /* Eep */ 4561da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Eep. add_full_dnode_to_inode() failed in commit_write, returned %d\n", ret)); 4571da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, fn->raw); 4581da177e4SLinus Torvalds jffs2_free_full_dnode(fn); 4591da177e4SLinus Torvalds 4601da177e4SLinus Torvalds up(&f->sem); 4611da177e4SLinus Torvalds jffs2_complete_reservation(c); 4621da177e4SLinus Torvalds break; 4631da177e4SLinus Torvalds } 4641da177e4SLinus Torvalds up(&f->sem); 4651da177e4SLinus Torvalds jffs2_complete_reservation(c); 4661da177e4SLinus Torvalds if (!datalen) { 4671da177e4SLinus Torvalds printk(KERN_WARNING "Eep. We didn't actually write any data in jffs2_write_inode_range()\n"); 4681da177e4SLinus Torvalds ret = -EIO; 4691da177e4SLinus Torvalds break; 4701da177e4SLinus Torvalds } 4711da177e4SLinus Torvalds D1(printk(KERN_DEBUG "increasing writtenlen by %d\n", datalen)); 4721da177e4SLinus Torvalds writtenlen += datalen; 4731da177e4SLinus Torvalds offset += datalen; 4741da177e4SLinus Torvalds writelen -= datalen; 4751da177e4SLinus Torvalds buf += datalen; 4761da177e4SLinus Torvalds } 4771da177e4SLinus Torvalds *retlen = writtenlen; 4781da177e4SLinus Torvalds return ret; 4791da177e4SLinus Torvalds } 4801da177e4SLinus Torvalds 4811da177e4SLinus 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) 4821da177e4SLinus Torvalds { 4831da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 4841da177e4SLinus Torvalds struct jffs2_full_dnode *fn; 4851da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 4861da177e4SLinus Torvalds uint32_t alloclen, phys_ofs; 4871da177e4SLinus Torvalds int ret; 4881da177e4SLinus Torvalds 4891da177e4SLinus Torvalds /* Try to reserve enough space for both node and dirent. 4901da177e4SLinus Torvalds * Just the node will do for now, though 4911da177e4SLinus Torvalds */ 4921da177e4SLinus Torvalds ret = jffs2_reserve_space(c, sizeof(*ri), &phys_ofs, &alloclen, ALLOC_NORMAL); 4931da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_do_create(): reserved 0x%x bytes\n", alloclen)); 4941da177e4SLinus Torvalds if (ret) { 4951da177e4SLinus Torvalds up(&f->sem); 4961da177e4SLinus Torvalds return ret; 4971da177e4SLinus Torvalds } 4981da177e4SLinus Torvalds 4991da177e4SLinus Torvalds ri->data_crc = cpu_to_je32(0); 5001da177e4SLinus Torvalds ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 5011da177e4SLinus Torvalds 5021da177e4SLinus Torvalds fn = jffs2_write_dnode(c, f, ri, NULL, 0, phys_ofs, ALLOC_NORMAL); 5031da177e4SLinus Torvalds 5041da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_do_create created file with mode 0x%x\n", 5051da177e4SLinus Torvalds jemode_to_cpu(ri->mode))); 5061da177e4SLinus Torvalds 5071da177e4SLinus Torvalds if (IS_ERR(fn)) { 5081da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_write_dnode() failed\n")); 5091da177e4SLinus Torvalds /* Eeek. Wave bye bye */ 5101da177e4SLinus Torvalds up(&f->sem); 5111da177e4SLinus Torvalds jffs2_complete_reservation(c); 5121da177e4SLinus Torvalds return PTR_ERR(fn); 5131da177e4SLinus Torvalds } 5141da177e4SLinus Torvalds /* No data here. Only a metadata node, which will be 5151da177e4SLinus Torvalds obsoleted by the first data write 5161da177e4SLinus Torvalds */ 5171da177e4SLinus Torvalds f->metadata = fn; 5181da177e4SLinus Torvalds 5191da177e4SLinus Torvalds up(&f->sem); 5201da177e4SLinus Torvalds jffs2_complete_reservation(c); 5211da177e4SLinus Torvalds ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen, ALLOC_NORMAL); 5221da177e4SLinus Torvalds 5231da177e4SLinus Torvalds if (ret) { 5241da177e4SLinus Torvalds /* Eep. */ 5251da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_reserve_space() for dirent failed\n")); 5261da177e4SLinus Torvalds return ret; 5271da177e4SLinus Torvalds } 5281da177e4SLinus Torvalds 5291da177e4SLinus Torvalds rd = jffs2_alloc_raw_dirent(); 5301da177e4SLinus Torvalds if (!rd) { 5311da177e4SLinus Torvalds /* Argh. Now we treat it like a normal delete */ 5321da177e4SLinus Torvalds jffs2_complete_reservation(c); 5331da177e4SLinus Torvalds return -ENOMEM; 5341da177e4SLinus Torvalds } 5351da177e4SLinus Torvalds 5361da177e4SLinus Torvalds down(&dir_f->sem); 5371da177e4SLinus Torvalds 5381da177e4SLinus Torvalds rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 5391da177e4SLinus Torvalds rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 5401da177e4SLinus Torvalds rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 5411da177e4SLinus Torvalds rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 5421da177e4SLinus Torvalds 5431da177e4SLinus Torvalds rd->pino = cpu_to_je32(dir_f->inocache->ino); 5441da177e4SLinus Torvalds rd->version = cpu_to_je32(++dir_f->highest_version); 5451da177e4SLinus Torvalds rd->ino = ri->ino; 5461da177e4SLinus Torvalds rd->mctime = ri->ctime; 5471da177e4SLinus Torvalds rd->nsize = namelen; 5481da177e4SLinus Torvalds rd->type = DT_REG; 5491da177e4SLinus Torvalds rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 5501da177e4SLinus Torvalds rd->name_crc = cpu_to_je32(crc32(0, name, namelen)); 5511da177e4SLinus Torvalds 5521da177e4SLinus Torvalds fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, phys_ofs, ALLOC_NORMAL); 5531da177e4SLinus Torvalds 5541da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 5551da177e4SLinus Torvalds 5561da177e4SLinus Torvalds if (IS_ERR(fd)) { 5571da177e4SLinus Torvalds /* dirent failed to write. Delete the inode normally 5581da177e4SLinus Torvalds as if it were the final unlink() */ 5591da177e4SLinus Torvalds jffs2_complete_reservation(c); 5601da177e4SLinus Torvalds up(&dir_f->sem); 5611da177e4SLinus Torvalds return PTR_ERR(fd); 5621da177e4SLinus Torvalds } 5631da177e4SLinus Torvalds 5641da177e4SLinus Torvalds /* Link the fd into the inode's list, obsoleting an old 5651da177e4SLinus Torvalds one if necessary. */ 5661da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &dir_f->dents); 5671da177e4SLinus Torvalds 5681da177e4SLinus Torvalds jffs2_complete_reservation(c); 5691da177e4SLinus Torvalds up(&dir_f->sem); 5701da177e4SLinus Torvalds 5711da177e4SLinus Torvalds return 0; 5721da177e4SLinus Torvalds } 5731da177e4SLinus Torvalds 5741da177e4SLinus Torvalds 5751da177e4SLinus Torvalds int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, 5761da177e4SLinus Torvalds const char *name, int namelen, struct jffs2_inode_info *dead_f) 5771da177e4SLinus Torvalds { 5781da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 5791da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 5801da177e4SLinus Torvalds uint32_t alloclen, phys_ofs; 5811da177e4SLinus Torvalds int ret; 5821da177e4SLinus Torvalds 5831da177e4SLinus Torvalds if (1 /* alternative branch needs testing */ || 5841da177e4SLinus Torvalds !jffs2_can_mark_obsolete(c)) { 5851da177e4SLinus Torvalds /* We can't mark stuff obsolete on the medium. We need to write a deletion dirent */ 5861da177e4SLinus Torvalds 5871da177e4SLinus Torvalds rd = jffs2_alloc_raw_dirent(); 5881da177e4SLinus Torvalds if (!rd) 5891da177e4SLinus Torvalds return -ENOMEM; 5901da177e4SLinus Torvalds 5911da177e4SLinus Torvalds ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen, ALLOC_DELETION); 5921da177e4SLinus Torvalds if (ret) { 5931da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 5941da177e4SLinus Torvalds return ret; 5951da177e4SLinus Torvalds } 5961da177e4SLinus Torvalds 5971da177e4SLinus Torvalds down(&dir_f->sem); 5981da177e4SLinus Torvalds 5991da177e4SLinus Torvalds /* Build a deletion node */ 6001da177e4SLinus Torvalds rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 6011da177e4SLinus Torvalds rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 6021da177e4SLinus Torvalds rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 6031da177e4SLinus Torvalds rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 6041da177e4SLinus Torvalds 6051da177e4SLinus Torvalds rd->pino = cpu_to_je32(dir_f->inocache->ino); 6061da177e4SLinus Torvalds rd->version = cpu_to_je32(++dir_f->highest_version); 6071da177e4SLinus Torvalds rd->ino = cpu_to_je32(0); 6081da177e4SLinus Torvalds rd->mctime = cpu_to_je32(get_seconds()); 6091da177e4SLinus Torvalds rd->nsize = namelen; 6101da177e4SLinus Torvalds rd->type = DT_UNKNOWN; 6111da177e4SLinus Torvalds rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 6121da177e4SLinus Torvalds rd->name_crc = cpu_to_je32(crc32(0, name, namelen)); 6131da177e4SLinus Torvalds 6141da177e4SLinus Torvalds fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, phys_ofs, ALLOC_DELETION); 6151da177e4SLinus Torvalds 6161da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 6171da177e4SLinus Torvalds 6181da177e4SLinus Torvalds if (IS_ERR(fd)) { 6191da177e4SLinus Torvalds jffs2_complete_reservation(c); 6201da177e4SLinus Torvalds up(&dir_f->sem); 6211da177e4SLinus Torvalds return PTR_ERR(fd); 6221da177e4SLinus Torvalds } 6231da177e4SLinus Torvalds 6241da177e4SLinus Torvalds /* File it. This will mark the old one obsolete. */ 6251da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &dir_f->dents); 6261da177e4SLinus Torvalds up(&dir_f->sem); 6271da177e4SLinus Torvalds } else { 6281da177e4SLinus Torvalds struct jffs2_full_dirent **prev = &dir_f->dents; 6291da177e4SLinus Torvalds uint32_t nhash = full_name_hash(name, namelen); 6301da177e4SLinus Torvalds 6311da177e4SLinus Torvalds down(&dir_f->sem); 6321da177e4SLinus Torvalds 6331da177e4SLinus Torvalds while ((*prev) && (*prev)->nhash <= nhash) { 6341da177e4SLinus Torvalds if ((*prev)->nhash == nhash && 6351da177e4SLinus Torvalds !memcmp((*prev)->name, name, namelen) && 6361da177e4SLinus Torvalds !(*prev)->name[namelen]) { 6371da177e4SLinus Torvalds struct jffs2_full_dirent *this = *prev; 6381da177e4SLinus Torvalds 6391da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Marking old dirent node (ino #%u) @%08x obsolete\n", 6401da177e4SLinus Torvalds this->ino, ref_offset(this->raw))); 6411da177e4SLinus Torvalds 6421da177e4SLinus Torvalds *prev = this->next; 6431da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, (this->raw)); 6441da177e4SLinus Torvalds jffs2_free_full_dirent(this); 6451da177e4SLinus Torvalds break; 6461da177e4SLinus Torvalds } 6471da177e4SLinus Torvalds prev = &((*prev)->next); 6481da177e4SLinus Torvalds } 6491da177e4SLinus Torvalds up(&dir_f->sem); 6501da177e4SLinus Torvalds } 6511da177e4SLinus Torvalds 6521da177e4SLinus Torvalds /* dead_f is NULL if this was a rename not a real unlink */ 6531da177e4SLinus Torvalds /* Also catch the !f->inocache case, where there was a dirent 6541da177e4SLinus Torvalds pointing to an inode which didn't exist. */ 6551da177e4SLinus Torvalds if (dead_f && dead_f->inocache) { 6561da177e4SLinus Torvalds 6571da177e4SLinus Torvalds down(&dead_f->sem); 6581da177e4SLinus Torvalds 6591da177e4SLinus Torvalds while (dead_f->dents) { 6601da177e4SLinus Torvalds /* There can be only deleted ones */ 6611da177e4SLinus Torvalds fd = dead_f->dents; 6621da177e4SLinus Torvalds 6631da177e4SLinus Torvalds dead_f->dents = fd->next; 6641da177e4SLinus Torvalds 6651da177e4SLinus Torvalds if (fd->ino) { 6661da177e4SLinus Torvalds printk(KERN_WARNING "Deleting inode #%u with active dentry \"%s\"->ino #%u\n", 6671da177e4SLinus Torvalds dead_f->inocache->ino, fd->name, fd->ino); 6681da177e4SLinus Torvalds } else { 6691da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Removing deletion dirent for \"%s\" from dir ino #%u\n", fd->name, dead_f->inocache->ino)); 6701da177e4SLinus Torvalds } 6711da177e4SLinus Torvalds jffs2_mark_node_obsolete(c, fd->raw); 6721da177e4SLinus Torvalds jffs2_free_full_dirent(fd); 6731da177e4SLinus Torvalds } 6741da177e4SLinus Torvalds 6751da177e4SLinus Torvalds dead_f->inocache->nlink--; 6761da177e4SLinus Torvalds /* NB: Caller must set inode nlink if appropriate */ 6771da177e4SLinus Torvalds up(&dead_f->sem); 6781da177e4SLinus Torvalds } 6791da177e4SLinus Torvalds 6801da177e4SLinus Torvalds jffs2_complete_reservation(c); 6811da177e4SLinus Torvalds 6821da177e4SLinus Torvalds return 0; 6831da177e4SLinus Torvalds } 6841da177e4SLinus Torvalds 6851da177e4SLinus Torvalds 6861da177e4SLinus Torvalds 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) 6871da177e4SLinus Torvalds { 6881da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 6891da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 6901da177e4SLinus Torvalds uint32_t alloclen, phys_ofs; 6911da177e4SLinus Torvalds int ret; 6921da177e4SLinus Torvalds 6931da177e4SLinus Torvalds rd = jffs2_alloc_raw_dirent(); 6941da177e4SLinus Torvalds if (!rd) 6951da177e4SLinus Torvalds return -ENOMEM; 6961da177e4SLinus Torvalds 6971da177e4SLinus Torvalds ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen, ALLOC_NORMAL); 6981da177e4SLinus Torvalds if (ret) { 6991da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 7001da177e4SLinus Torvalds return ret; 7011da177e4SLinus Torvalds } 7021da177e4SLinus Torvalds 7031da177e4SLinus Torvalds down(&dir_f->sem); 7041da177e4SLinus Torvalds 7051da177e4SLinus Torvalds /* Build a deletion node */ 7061da177e4SLinus Torvalds rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 7071da177e4SLinus Torvalds rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 7081da177e4SLinus Torvalds rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 7091da177e4SLinus Torvalds rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 7101da177e4SLinus Torvalds 7111da177e4SLinus Torvalds rd->pino = cpu_to_je32(dir_f->inocache->ino); 7121da177e4SLinus Torvalds rd->version = cpu_to_je32(++dir_f->highest_version); 7131da177e4SLinus Torvalds rd->ino = cpu_to_je32(ino); 7141da177e4SLinus Torvalds rd->mctime = cpu_to_je32(get_seconds()); 7151da177e4SLinus Torvalds rd->nsize = namelen; 7161da177e4SLinus Torvalds 7171da177e4SLinus Torvalds rd->type = type; 7181da177e4SLinus Torvalds 7191da177e4SLinus Torvalds rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 7201da177e4SLinus Torvalds rd->name_crc = cpu_to_je32(crc32(0, name, namelen)); 7211da177e4SLinus Torvalds 7221da177e4SLinus Torvalds fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, phys_ofs, ALLOC_NORMAL); 7231da177e4SLinus Torvalds 7241da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 7251da177e4SLinus Torvalds 7261da177e4SLinus Torvalds if (IS_ERR(fd)) { 7271da177e4SLinus Torvalds jffs2_complete_reservation(c); 7281da177e4SLinus Torvalds up(&dir_f->sem); 7291da177e4SLinus Torvalds return PTR_ERR(fd); 7301da177e4SLinus Torvalds } 7311da177e4SLinus Torvalds 7321da177e4SLinus Torvalds /* File it. This will mark the old one obsolete. */ 7331da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &dir_f->dents); 7341da177e4SLinus Torvalds 7351da177e4SLinus Torvalds jffs2_complete_reservation(c); 7361da177e4SLinus Torvalds up(&dir_f->sem); 7371da177e4SLinus Torvalds 7381da177e4SLinus Torvalds return 0; 7391da177e4SLinus Torvalds } 740