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/slab.h> 141da177e4SLinus Torvalds #include <linux/fs.h> 151da177e4SLinus Torvalds #include <linux/crc32.h> 161da177e4SLinus Torvalds #include <linux/jffs2.h> 17cbb9a561SDavid Woodhouse #include "jffs2_fs_i.h" 18cbb9a561SDavid Woodhouse #include "jffs2_fs_sb.h" 191da177e4SLinus Torvalds #include <linux/time.h> 201da177e4SLinus Torvalds #include "nodelist.h" 211da177e4SLinus Torvalds 221da177e4SLinus Torvalds static int jffs2_readdir (struct file *, void *, filldir_t); 231da177e4SLinus Torvalds 241da177e4SLinus Torvalds static int jffs2_create (struct inode *,struct dentry *,int, 251da177e4SLinus Torvalds struct nameidata *); 261da177e4SLinus Torvalds static struct dentry *jffs2_lookup (struct inode *,struct dentry *, 271da177e4SLinus Torvalds struct nameidata *); 281da177e4SLinus Torvalds static int jffs2_link (struct dentry *,struct inode *,struct dentry *); 291da177e4SLinus Torvalds static int jffs2_unlink (struct inode *,struct dentry *); 301da177e4SLinus Torvalds static int jffs2_symlink (struct inode *,struct dentry *,const char *); 311da177e4SLinus Torvalds static int jffs2_mkdir (struct inode *,struct dentry *,int); 321da177e4SLinus Torvalds static int jffs2_rmdir (struct inode *,struct dentry *); 33265489f0SDavid Woodhouse static int jffs2_mknod (struct inode *,struct dentry *,int,dev_t); 341da177e4SLinus Torvalds static int jffs2_rename (struct inode *, struct dentry *, 351da177e4SLinus Torvalds struct inode *, struct dentry *); 361da177e4SLinus Torvalds 374b6f5d20SArjan van de Ven const struct file_operations jffs2_dir_operations = 381da177e4SLinus Torvalds { 391da177e4SLinus Torvalds .read = generic_read_dir, 401da177e4SLinus Torvalds .readdir = jffs2_readdir, 410533400bSStoyan Gaydarov .unlocked_ioctl=jffs2_ioctl, 423222a3e5SChristoph Hellwig .fsync = jffs2_fsync, 433222a3e5SChristoph Hellwig .llseek = generic_file_llseek, 441da177e4SLinus Torvalds }; 451da177e4SLinus Torvalds 461da177e4SLinus Torvalds 4792e1d5beSArjan van de Ven const struct inode_operations jffs2_dir_inode_operations = 481da177e4SLinus Torvalds { 49265489f0SDavid Woodhouse .create = jffs2_create, 50265489f0SDavid Woodhouse .lookup = jffs2_lookup, 511da177e4SLinus Torvalds .link = jffs2_link, 521da177e4SLinus Torvalds .unlink = jffs2_unlink, 531da177e4SLinus Torvalds .symlink = jffs2_symlink, 541da177e4SLinus Torvalds .mkdir = jffs2_mkdir, 551da177e4SLinus Torvalds .rmdir = jffs2_rmdir, 561da177e4SLinus Torvalds .mknod = jffs2_mknod, 571da177e4SLinus Torvalds .rename = jffs2_rename, 5818f4c644SLinus Torvalds .check_acl = jffs2_check_acl, 591da177e4SLinus Torvalds .setattr = jffs2_setattr, 60aa98d7cfSKaiGai Kohei .setxattr = jffs2_setxattr, 61aa98d7cfSKaiGai Kohei .getxattr = jffs2_getxattr, 62aa98d7cfSKaiGai Kohei .listxattr = jffs2_listxattr, 63aa98d7cfSKaiGai Kohei .removexattr = jffs2_removexattr 641da177e4SLinus Torvalds }; 651da177e4SLinus Torvalds 661da177e4SLinus Torvalds /***********************************************************************/ 671da177e4SLinus Torvalds 681da177e4SLinus Torvalds 691da177e4SLinus Torvalds /* We keep the dirent list sorted in increasing order of name hash, 701da177e4SLinus Torvalds and we use the same hash function as the dentries. Makes this 711da177e4SLinus Torvalds nice and simple 721da177e4SLinus Torvalds */ 731da177e4SLinus Torvalds static struct dentry *jffs2_lookup(struct inode *dir_i, struct dentry *target, 741da177e4SLinus Torvalds struct nameidata *nd) 751da177e4SLinus Torvalds { 761da177e4SLinus Torvalds struct jffs2_inode_info *dir_f; 771da177e4SLinus Torvalds struct jffs2_sb_info *c; 781da177e4SLinus Torvalds struct jffs2_full_dirent *fd = NULL, *fd_list; 791da177e4SLinus Torvalds uint32_t ino = 0; 801da177e4SLinus Torvalds struct inode *inode = NULL; 811da177e4SLinus Torvalds 821da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_lookup()\n")); 831da177e4SLinus Torvalds 84373d5e71SRichard Purdie if (target->d_name.len > JFFS2_MAX_NAME_LEN) 85373d5e71SRichard Purdie return ERR_PTR(-ENAMETOOLONG); 86373d5e71SRichard Purdie 871da177e4SLinus Torvalds dir_f = JFFS2_INODE_INFO(dir_i); 881da177e4SLinus Torvalds c = JFFS2_SB_INFO(dir_i->i_sb); 891da177e4SLinus Torvalds 90ced22070SDavid Woodhouse mutex_lock(&dir_f->sem); 911da177e4SLinus Torvalds 921da177e4SLinus Torvalds /* NB: The 2.2 backport will need to explicitly check for '.' and '..' here */ 931da177e4SLinus Torvalds for (fd_list = dir_f->dents; fd_list && fd_list->nhash <= target->d_name.hash; fd_list = fd_list->next) { 941da177e4SLinus Torvalds if (fd_list->nhash == target->d_name.hash && 951da177e4SLinus Torvalds (!fd || fd_list->version > fd->version) && 961da177e4SLinus Torvalds strlen(fd_list->name) == target->d_name.len && 971da177e4SLinus Torvalds !strncmp(fd_list->name, target->d_name.name, target->d_name.len)) { 981da177e4SLinus Torvalds fd = fd_list; 991da177e4SLinus Torvalds } 1001da177e4SLinus Torvalds } 1011da177e4SLinus Torvalds if (fd) 1021da177e4SLinus Torvalds ino = fd->ino; 103ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 1041da177e4SLinus Torvalds if (ino) { 1055451f79fSDavid Howells inode = jffs2_iget(dir_i->i_sb, ino); 1065451f79fSDavid Howells if (IS_ERR(inode)) { 1071da177e4SLinus Torvalds printk(KERN_WARNING "iget() failed for ino #%u\n", ino); 1085451f79fSDavid Howells return ERR_CAST(inode); 1091da177e4SLinus Torvalds } 1101da177e4SLinus Torvalds } 1111da177e4SLinus Torvalds 1128966c5e0SDavid Woodhouse return d_splice_alias(inode, target); 1131da177e4SLinus Torvalds } 1141da177e4SLinus Torvalds 1151da177e4SLinus Torvalds /***********************************************************************/ 1161da177e4SLinus Torvalds 1171da177e4SLinus Torvalds 1181da177e4SLinus Torvalds static int jffs2_readdir(struct file *filp, void *dirent, filldir_t filldir) 1191da177e4SLinus Torvalds { 1201da177e4SLinus Torvalds struct jffs2_inode_info *f; 1211da177e4SLinus Torvalds struct jffs2_sb_info *c; 122ec2e203cSJosef Sipek struct inode *inode = filp->f_path.dentry->d_inode; 1231da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 1241da177e4SLinus Torvalds unsigned long offset, curofs; 1251da177e4SLinus Torvalds 126ec2e203cSJosef Sipek D1(printk(KERN_DEBUG "jffs2_readdir() for dir_i #%lu\n", filp->f_path.dentry->d_inode->i_ino)); 1271da177e4SLinus Torvalds 1281da177e4SLinus Torvalds f = JFFS2_INODE_INFO(inode); 1291da177e4SLinus Torvalds c = JFFS2_SB_INFO(inode->i_sb); 1301da177e4SLinus Torvalds 1311da177e4SLinus Torvalds offset = filp->f_pos; 1321da177e4SLinus Torvalds 1331da177e4SLinus Torvalds if (offset == 0) { 1341da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Dirent 0: \".\", ino #%lu\n", inode->i_ino)); 1351da177e4SLinus Torvalds if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR) < 0) 1361da177e4SLinus Torvalds goto out; 1371da177e4SLinus Torvalds offset++; 1381da177e4SLinus Torvalds } 1391da177e4SLinus Torvalds if (offset == 1) { 140ec2e203cSJosef Sipek unsigned long pino = parent_ino(filp->f_path.dentry); 1411da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Dirent 1: \"..\", ino #%lu\n", pino)); 1421da177e4SLinus Torvalds if (filldir(dirent, "..", 2, 1, pino, DT_DIR) < 0) 1431da177e4SLinus Torvalds goto out; 1441da177e4SLinus Torvalds offset++; 1451da177e4SLinus Torvalds } 1461da177e4SLinus Torvalds 1471da177e4SLinus Torvalds curofs=1; 148ced22070SDavid Woodhouse mutex_lock(&f->sem); 1491da177e4SLinus Torvalds for (fd = f->dents; fd; fd = fd->next) { 1501da177e4SLinus Torvalds 1511da177e4SLinus Torvalds curofs++; 1521da177e4SLinus Torvalds /* First loop: curofs = 2; offset = 2 */ 1531da177e4SLinus Torvalds if (curofs < offset) { 1541da177e4SLinus Torvalds D2(printk(KERN_DEBUG "Skipping dirent: \"%s\", ino #%u, type %d, because curofs %ld < offset %ld\n", 1551da177e4SLinus Torvalds fd->name, fd->ino, fd->type, curofs, offset)); 1561da177e4SLinus Torvalds continue; 1571da177e4SLinus Torvalds } 1581da177e4SLinus Torvalds if (!fd->ino) { 1591da177e4SLinus Torvalds D2(printk(KERN_DEBUG "Skipping deletion dirent \"%s\"\n", fd->name)); 1601da177e4SLinus Torvalds offset++; 1611da177e4SLinus Torvalds continue; 1621da177e4SLinus Torvalds } 1631da177e4SLinus Torvalds D2(printk(KERN_DEBUG "Dirent %ld: \"%s\", ino #%u, type %d\n", offset, fd->name, fd->ino, fd->type)); 1641da177e4SLinus Torvalds if (filldir(dirent, fd->name, strlen(fd->name), offset, fd->ino, fd->type) < 0) 1651da177e4SLinus Torvalds break; 1661da177e4SLinus Torvalds offset++; 1671da177e4SLinus Torvalds } 168ced22070SDavid Woodhouse mutex_unlock(&f->sem); 1691da177e4SLinus Torvalds out: 1701da177e4SLinus Torvalds filp->f_pos = offset; 1711da177e4SLinus Torvalds return 0; 1721da177e4SLinus Torvalds } 1731da177e4SLinus Torvalds 1741da177e4SLinus Torvalds /***********************************************************************/ 1751da177e4SLinus Torvalds 1761da177e4SLinus Torvalds 1771da177e4SLinus Torvalds static int jffs2_create(struct inode *dir_i, struct dentry *dentry, int mode, 1781da177e4SLinus Torvalds struct nameidata *nd) 1791da177e4SLinus Torvalds { 1801da177e4SLinus Torvalds struct jffs2_raw_inode *ri; 1811da177e4SLinus Torvalds struct jffs2_inode_info *f, *dir_f; 1821da177e4SLinus Torvalds struct jffs2_sb_info *c; 1831da177e4SLinus Torvalds struct inode *inode; 1841da177e4SLinus Torvalds int ret; 1851da177e4SLinus Torvalds 1861da177e4SLinus Torvalds ri = jffs2_alloc_raw_inode(); 1871da177e4SLinus Torvalds if (!ri) 1881da177e4SLinus Torvalds return -ENOMEM; 1891da177e4SLinus Torvalds 1901da177e4SLinus Torvalds c = JFFS2_SB_INFO(dir_i->i_sb); 1911da177e4SLinus Torvalds 1921da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_create()\n")); 1931da177e4SLinus Torvalds 194cfc8dc6fSKaiGai Kohei inode = jffs2_new_inode(dir_i, mode, ri); 1951da177e4SLinus Torvalds 1961da177e4SLinus Torvalds if (IS_ERR(inode)) { 1971da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_new_inode() failed\n")); 1981da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 1991da177e4SLinus Torvalds return PTR_ERR(inode); 2001da177e4SLinus Torvalds } 2011da177e4SLinus Torvalds 2021da177e4SLinus Torvalds inode->i_op = &jffs2_file_inode_operations; 2031da177e4SLinus Torvalds inode->i_fop = &jffs2_file_operations; 2041da177e4SLinus Torvalds inode->i_mapping->a_ops = &jffs2_file_address_operations; 2051da177e4SLinus Torvalds inode->i_mapping->nrpages = 0; 2061da177e4SLinus Torvalds 2071da177e4SLinus Torvalds f = JFFS2_INODE_INFO(inode); 2081da177e4SLinus Torvalds dir_f = JFFS2_INODE_INFO(dir_i); 2091da177e4SLinus Torvalds 210590fe34cSDavid Woodhouse /* jffs2_do_create() will want to lock it, _after_ reserving 211590fe34cSDavid Woodhouse space and taking c-alloc_sem. If we keep it locked here, 212590fe34cSDavid Woodhouse lockdep gets unhappy (although it's a false positive; 213590fe34cSDavid Woodhouse nothing else will be looking at this inode yet so there's 214590fe34cSDavid Woodhouse no chance of AB-BA deadlock involving its f->sem). */ 215590fe34cSDavid Woodhouse mutex_unlock(&f->sem); 216590fe34cSDavid Woodhouse 2171da177e4SLinus Torvalds ret = jffs2_do_create(c, dir_f, f, ri, 2181da177e4SLinus Torvalds dentry->d_name.name, dentry->d_name.len); 219aa98d7cfSKaiGai Kohei if (ret) 220aa98d7cfSKaiGai Kohei goto fail; 2211da177e4SLinus Torvalds 2221da177e4SLinus Torvalds dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(ri->ctime)); 2231da177e4SLinus Torvalds 2241da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 2251da177e4SLinus Torvalds 2261da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_create: Created ino #%lu with mode %o, nlink %d(%d). nrpages %ld\n", 22727c72b04SDavid Woodhouse inode->i_ino, inode->i_mode, inode->i_nlink, 22827c72b04SDavid Woodhouse f->inocache->pino_nlink, inode->i_mapping->nrpages)); 229e72e6497SDavid Woodhouse 230e72e6497SDavid Woodhouse d_instantiate(dentry, inode); 231e72e6497SDavid Woodhouse unlock_new_inode(inode); 2321da177e4SLinus Torvalds return 0; 233aa98d7cfSKaiGai Kohei 234aa98d7cfSKaiGai Kohei fail: 23541cce647SAl Viro iget_failed(inode); 236aa98d7cfSKaiGai Kohei jffs2_free_raw_inode(ri); 237aa98d7cfSKaiGai Kohei return ret; 2381da177e4SLinus Torvalds } 2391da177e4SLinus Torvalds 2401da177e4SLinus Torvalds /***********************************************************************/ 2411da177e4SLinus Torvalds 2421da177e4SLinus Torvalds 2431da177e4SLinus Torvalds static int jffs2_unlink(struct inode *dir_i, struct dentry *dentry) 2441da177e4SLinus Torvalds { 2451da177e4SLinus Torvalds struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb); 2461da177e4SLinus Torvalds struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); 2471da177e4SLinus Torvalds struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(dentry->d_inode); 2481da177e4SLinus Torvalds int ret; 2493a69e0cdSArtem B. Bityutskiy uint32_t now = get_seconds(); 2501da177e4SLinus Torvalds 2511da177e4SLinus Torvalds ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name, 2523a69e0cdSArtem B. Bityutskiy dentry->d_name.len, dead_f, now); 2531da177e4SLinus Torvalds if (dead_f->inocache) 25427c72b04SDavid Woodhouse dentry->d_inode->i_nlink = dead_f->inocache->pino_nlink; 2553a69e0cdSArtem B. Bityutskiy if (!ret) 2563a69e0cdSArtem B. Bityutskiy dir_i->i_mtime = dir_i->i_ctime = ITIME(now); 2571da177e4SLinus Torvalds return ret; 2581da177e4SLinus Torvalds } 2591da177e4SLinus Torvalds /***********************************************************************/ 2601da177e4SLinus Torvalds 2611da177e4SLinus Torvalds 2621da177e4SLinus Torvalds static int jffs2_link (struct dentry *old_dentry, struct inode *dir_i, struct dentry *dentry) 2631da177e4SLinus Torvalds { 2641da177e4SLinus Torvalds struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dentry->d_inode->i_sb); 2651da177e4SLinus Torvalds struct jffs2_inode_info *f = JFFS2_INODE_INFO(old_dentry->d_inode); 2661da177e4SLinus Torvalds struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); 2671da177e4SLinus Torvalds int ret; 2681da177e4SLinus Torvalds uint8_t type; 2693a69e0cdSArtem B. Bityutskiy uint32_t now; 2701da177e4SLinus Torvalds 2711da177e4SLinus Torvalds /* Don't let people make hard links to bad inodes. */ 2721da177e4SLinus Torvalds if (!f->inocache) 2731da177e4SLinus Torvalds return -EIO; 2741da177e4SLinus Torvalds 2751da177e4SLinus Torvalds if (S_ISDIR(old_dentry->d_inode->i_mode)) 2761da177e4SLinus Torvalds return -EPERM; 2771da177e4SLinus Torvalds 2781da177e4SLinus Torvalds /* XXX: This is ugly */ 2791da177e4SLinus Torvalds type = (old_dentry->d_inode->i_mode & S_IFMT) >> 12; 2801da177e4SLinus Torvalds if (!type) type = DT_REG; 2811da177e4SLinus Torvalds 2823a69e0cdSArtem B. Bityutskiy now = get_seconds(); 2833a69e0cdSArtem B. Bityutskiy ret = jffs2_do_link(c, dir_f, f->inocache->ino, type, dentry->d_name.name, dentry->d_name.len, now); 2841da177e4SLinus Torvalds 2851da177e4SLinus Torvalds if (!ret) { 286ced22070SDavid Woodhouse mutex_lock(&f->sem); 28727c72b04SDavid Woodhouse old_dentry->d_inode->i_nlink = ++f->inocache->pino_nlink; 288ced22070SDavid Woodhouse mutex_unlock(&f->sem); 2891da177e4SLinus Torvalds d_instantiate(dentry, old_dentry->d_inode); 2903a69e0cdSArtem B. Bityutskiy dir_i->i_mtime = dir_i->i_ctime = ITIME(now); 2911da177e4SLinus Torvalds atomic_inc(&old_dentry->d_inode->i_count); 2921da177e4SLinus Torvalds } 2931da177e4SLinus Torvalds return ret; 2941da177e4SLinus Torvalds } 2951da177e4SLinus Torvalds 2961da177e4SLinus Torvalds /***********************************************************************/ 2971da177e4SLinus Torvalds 2981da177e4SLinus Torvalds static int jffs2_symlink (struct inode *dir_i, struct dentry *dentry, const char *target) 2991da177e4SLinus Torvalds { 3001da177e4SLinus Torvalds struct jffs2_inode_info *f, *dir_f; 3011da177e4SLinus Torvalds struct jffs2_sb_info *c; 3021da177e4SLinus Torvalds struct inode *inode; 3031da177e4SLinus Torvalds struct jffs2_raw_inode *ri; 3041da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 3051da177e4SLinus Torvalds struct jffs2_full_dnode *fn; 3061da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 3071da177e4SLinus Torvalds int namelen; 3089fe4854cSDavid Woodhouse uint32_t alloclen; 30932f1a95dSArtem B. Bityuckiy int ret, targetlen = strlen(target); 3101da177e4SLinus Torvalds 3111da177e4SLinus Torvalds /* FIXME: If you care. We'd need to use frags for the target 3121da177e4SLinus Torvalds if it grows much more than this */ 31332f1a95dSArtem B. Bityuckiy if (targetlen > 254) 314bde86fecSAdrian Hunter return -ENAMETOOLONG; 3151da177e4SLinus Torvalds 3161da177e4SLinus Torvalds ri = jffs2_alloc_raw_inode(); 3171da177e4SLinus Torvalds 3181da177e4SLinus Torvalds if (!ri) 3191da177e4SLinus Torvalds return -ENOMEM; 3201da177e4SLinus Torvalds 3211da177e4SLinus Torvalds c = JFFS2_SB_INFO(dir_i->i_sb); 3221da177e4SLinus Torvalds 3231da177e4SLinus Torvalds /* Try to reserve enough space for both node and dirent. 3241da177e4SLinus Torvalds * Just the node will do for now, though 3251da177e4SLinus Torvalds */ 3261da177e4SLinus Torvalds namelen = dentry->d_name.len; 3279fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*ri) + targetlen, &alloclen, 328e631ddbaSFerenc Havasi ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE); 3291da177e4SLinus Torvalds 3301da177e4SLinus Torvalds if (ret) { 3311da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 3321da177e4SLinus Torvalds return ret; 3331da177e4SLinus Torvalds } 3341da177e4SLinus Torvalds 335cfc8dc6fSKaiGai Kohei inode = jffs2_new_inode(dir_i, S_IFLNK | S_IRWXUGO, ri); 3361da177e4SLinus Torvalds 3371da177e4SLinus Torvalds if (IS_ERR(inode)) { 3381da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 3391da177e4SLinus Torvalds jffs2_complete_reservation(c); 3401da177e4SLinus Torvalds return PTR_ERR(inode); 3411da177e4SLinus Torvalds } 3421da177e4SLinus Torvalds 3431da177e4SLinus Torvalds inode->i_op = &jffs2_symlink_inode_operations; 3441da177e4SLinus Torvalds 3451da177e4SLinus Torvalds f = JFFS2_INODE_INFO(inode); 3461da177e4SLinus Torvalds 34732f1a95dSArtem B. Bityuckiy inode->i_size = targetlen; 3481da177e4SLinus Torvalds ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size); 3491da177e4SLinus Torvalds ri->totlen = cpu_to_je32(sizeof(*ri) + inode->i_size); 3501da177e4SLinus Torvalds ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 3511da177e4SLinus Torvalds 3521da177e4SLinus Torvalds ri->compr = JFFS2_COMPR_NONE; 35332f1a95dSArtem B. Bityuckiy ri->data_crc = cpu_to_je32(crc32(0, target, targetlen)); 3541da177e4SLinus Torvalds ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 3551da177e4SLinus Torvalds 3569fe4854cSDavid Woodhouse fn = jffs2_write_dnode(c, f, ri, target, targetlen, ALLOC_NORMAL); 3571da177e4SLinus Torvalds 3581da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 3591da177e4SLinus Torvalds 3601da177e4SLinus Torvalds if (IS_ERR(fn)) { 3611da177e4SLinus Torvalds /* Eeek. Wave bye bye */ 362ced22070SDavid Woodhouse mutex_unlock(&f->sem); 3631da177e4SLinus Torvalds jffs2_complete_reservation(c); 364f324e4cbSDavid Woodhouse ret = PTR_ERR(fn); 365f324e4cbSDavid Woodhouse goto fail; 3661da177e4SLinus Torvalds } 36732f1a95dSArtem B. Bityuckiy 3682b79adccSArtem B. Bityutskiy /* We use f->target field to store the target path. */ 3692b79adccSArtem B. Bityutskiy f->target = kmalloc(targetlen + 1, GFP_KERNEL); 3702b79adccSArtem B. Bityutskiy if (!f->target) { 37132f1a95dSArtem B. Bityuckiy printk(KERN_WARNING "Can't allocate %d bytes of memory\n", targetlen + 1); 372ced22070SDavid Woodhouse mutex_unlock(&f->sem); 37332f1a95dSArtem B. Bityuckiy jffs2_complete_reservation(c); 374f324e4cbSDavid Woodhouse ret = -ENOMEM; 375f324e4cbSDavid Woodhouse goto fail; 37632f1a95dSArtem B. Bityuckiy } 37732f1a95dSArtem B. Bityuckiy 3782b79adccSArtem B. Bityutskiy memcpy(f->target, target, targetlen + 1); 3792b79adccSArtem B. Bityutskiy D1(printk(KERN_DEBUG "jffs2_symlink: symlink's target '%s' cached\n", (char *)f->target)); 38032f1a95dSArtem B. Bityuckiy 3811da177e4SLinus Torvalds /* No data here. Only a metadata node, which will be 3821da177e4SLinus Torvalds obsoleted by the first data write 3831da177e4SLinus Torvalds */ 3841da177e4SLinus Torvalds f->metadata = fn; 385ced22070SDavid Woodhouse mutex_unlock(&f->sem); 3861da177e4SLinus Torvalds 3871da177e4SLinus Torvalds jffs2_complete_reservation(c); 388aa98d7cfSKaiGai Kohei 389aa98d7cfSKaiGai Kohei ret = jffs2_init_security(inode, dir_i); 390f324e4cbSDavid Woodhouse if (ret) 391f324e4cbSDavid Woodhouse goto fail; 392f324e4cbSDavid Woodhouse 393cfc8dc6fSKaiGai Kohei ret = jffs2_init_acl_post(inode); 394f324e4cbSDavid Woodhouse if (ret) 395f324e4cbSDavid Woodhouse goto fail; 396aa98d7cfSKaiGai Kohei 3979fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 398e631ddbaSFerenc Havasi ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 399f324e4cbSDavid Woodhouse if (ret) 400f324e4cbSDavid Woodhouse goto fail; 4011da177e4SLinus Torvalds 4021da177e4SLinus Torvalds rd = jffs2_alloc_raw_dirent(); 4031da177e4SLinus Torvalds if (!rd) { 4041da177e4SLinus Torvalds /* Argh. Now we treat it like a normal delete */ 4051da177e4SLinus Torvalds jffs2_complete_reservation(c); 406f324e4cbSDavid Woodhouse ret = -ENOMEM; 407f324e4cbSDavid Woodhouse goto fail; 4081da177e4SLinus Torvalds } 4091da177e4SLinus Torvalds 4101da177e4SLinus Torvalds dir_f = JFFS2_INODE_INFO(dir_i); 411ced22070SDavid Woodhouse mutex_lock(&dir_f->sem); 4121da177e4SLinus Torvalds 4131da177e4SLinus Torvalds rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 4141da177e4SLinus Torvalds rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 4151da177e4SLinus Torvalds rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 4161da177e4SLinus Torvalds rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 4171da177e4SLinus Torvalds 4181da177e4SLinus Torvalds rd->pino = cpu_to_je32(dir_i->i_ino); 4191da177e4SLinus Torvalds rd->version = cpu_to_je32(++dir_f->highest_version); 4201da177e4SLinus Torvalds rd->ino = cpu_to_je32(inode->i_ino); 4211da177e4SLinus Torvalds rd->mctime = cpu_to_je32(get_seconds()); 4221da177e4SLinus Torvalds rd->nsize = namelen; 4231da177e4SLinus Torvalds rd->type = DT_LNK; 4241da177e4SLinus Torvalds rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 4251da177e4SLinus Torvalds rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen)); 4261da177e4SLinus Torvalds 4279fe4854cSDavid Woodhouse fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL); 4281da177e4SLinus Torvalds 4291da177e4SLinus Torvalds if (IS_ERR(fd)) { 4301da177e4SLinus Torvalds /* dirent failed to write. Delete the inode normally 4311da177e4SLinus Torvalds as if it were the final unlink() */ 4321da177e4SLinus Torvalds jffs2_complete_reservation(c); 4331da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 434ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 435f324e4cbSDavid Woodhouse ret = PTR_ERR(fd); 436f324e4cbSDavid Woodhouse goto fail; 4371da177e4SLinus Torvalds } 4381da177e4SLinus Torvalds 4391da177e4SLinus Torvalds dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime)); 4401da177e4SLinus Torvalds 4411da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 4421da177e4SLinus Torvalds 4431da177e4SLinus Torvalds /* Link the fd into the inode's list, obsoleting an old 4441da177e4SLinus Torvalds one if necessary. */ 4451da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &dir_f->dents); 4461da177e4SLinus Torvalds 447ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 4481da177e4SLinus Torvalds jffs2_complete_reservation(c); 4491da177e4SLinus Torvalds 4501da177e4SLinus Torvalds d_instantiate(dentry, inode); 451e72e6497SDavid Woodhouse unlock_new_inode(inode); 4521da177e4SLinus Torvalds return 0; 453f324e4cbSDavid Woodhouse 454f324e4cbSDavid Woodhouse fail: 45541cce647SAl Viro iget_failed(inode); 456f324e4cbSDavid Woodhouse return ret; 4571da177e4SLinus Torvalds } 4581da177e4SLinus Torvalds 4591da177e4SLinus Torvalds 4601da177e4SLinus Torvalds static int jffs2_mkdir (struct inode *dir_i, struct dentry *dentry, int mode) 4611da177e4SLinus Torvalds { 4621da177e4SLinus Torvalds struct jffs2_inode_info *f, *dir_f; 4631da177e4SLinus Torvalds struct jffs2_sb_info *c; 4641da177e4SLinus Torvalds struct inode *inode; 4651da177e4SLinus Torvalds struct jffs2_raw_inode *ri; 4661da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 4671da177e4SLinus Torvalds struct jffs2_full_dnode *fn; 4681da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 4691da177e4SLinus Torvalds int namelen; 4709fe4854cSDavid Woodhouse uint32_t alloclen; 4711da177e4SLinus Torvalds int ret; 4721da177e4SLinus Torvalds 4731da177e4SLinus Torvalds mode |= S_IFDIR; 4741da177e4SLinus Torvalds 4751da177e4SLinus Torvalds ri = jffs2_alloc_raw_inode(); 4761da177e4SLinus Torvalds if (!ri) 4771da177e4SLinus Torvalds return -ENOMEM; 4781da177e4SLinus Torvalds 4791da177e4SLinus Torvalds c = JFFS2_SB_INFO(dir_i->i_sb); 4801da177e4SLinus Torvalds 4811da177e4SLinus Torvalds /* Try to reserve enough space for both node and dirent. 4821da177e4SLinus Torvalds * Just the node will do for now, though 4831da177e4SLinus Torvalds */ 4841da177e4SLinus Torvalds namelen = dentry->d_name.len; 4859fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL, 486e631ddbaSFerenc Havasi JFFS2_SUMMARY_INODE_SIZE); 4871da177e4SLinus Torvalds 4881da177e4SLinus Torvalds if (ret) { 4891da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 4901da177e4SLinus Torvalds return ret; 4911da177e4SLinus Torvalds } 4921da177e4SLinus Torvalds 493cfc8dc6fSKaiGai Kohei inode = jffs2_new_inode(dir_i, mode, ri); 4941da177e4SLinus Torvalds 4951da177e4SLinus Torvalds if (IS_ERR(inode)) { 4961da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 4971da177e4SLinus Torvalds jffs2_complete_reservation(c); 4981da177e4SLinus Torvalds return PTR_ERR(inode); 4991da177e4SLinus Torvalds } 5001da177e4SLinus Torvalds 5011da177e4SLinus Torvalds inode->i_op = &jffs2_dir_inode_operations; 5021da177e4SLinus Torvalds inode->i_fop = &jffs2_dir_operations; 5031da177e4SLinus Torvalds 5041da177e4SLinus Torvalds f = JFFS2_INODE_INFO(inode); 5051da177e4SLinus Torvalds 50627c72b04SDavid Woodhouse /* Directories get nlink 2 at start */ 50727c72b04SDavid Woodhouse inode->i_nlink = 2; 50827c72b04SDavid Woodhouse /* but ic->pino_nlink is the parent ino# */ 50927c72b04SDavid Woodhouse f->inocache->pino_nlink = dir_i->i_ino; 51027c72b04SDavid Woodhouse 5111da177e4SLinus Torvalds ri->data_crc = cpu_to_je32(0); 5121da177e4SLinus Torvalds ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 5131da177e4SLinus Torvalds 5149fe4854cSDavid Woodhouse fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL); 5151da177e4SLinus Torvalds 5161da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 5171da177e4SLinus Torvalds 5181da177e4SLinus Torvalds if (IS_ERR(fn)) { 5191da177e4SLinus Torvalds /* Eeek. Wave bye bye */ 520ced22070SDavid Woodhouse mutex_unlock(&f->sem); 5211da177e4SLinus Torvalds jffs2_complete_reservation(c); 522f324e4cbSDavid Woodhouse ret = PTR_ERR(fn); 523f324e4cbSDavid Woodhouse goto fail; 5241da177e4SLinus Torvalds } 5251da177e4SLinus Torvalds /* No data here. Only a metadata node, which will be 5261da177e4SLinus Torvalds obsoleted by the first data write 5271da177e4SLinus Torvalds */ 5281da177e4SLinus Torvalds f->metadata = fn; 529ced22070SDavid Woodhouse mutex_unlock(&f->sem); 5301da177e4SLinus Torvalds 5311da177e4SLinus Torvalds jffs2_complete_reservation(c); 532aa98d7cfSKaiGai Kohei 533aa98d7cfSKaiGai Kohei ret = jffs2_init_security(inode, dir_i); 534f324e4cbSDavid Woodhouse if (ret) 535f324e4cbSDavid Woodhouse goto fail; 536f324e4cbSDavid Woodhouse 537cfc8dc6fSKaiGai Kohei ret = jffs2_init_acl_post(inode); 538f324e4cbSDavid Woodhouse if (ret) 539f324e4cbSDavid Woodhouse goto fail; 540aa98d7cfSKaiGai Kohei 5419fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 542e631ddbaSFerenc Havasi ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 543f324e4cbSDavid Woodhouse if (ret) 544f324e4cbSDavid Woodhouse goto fail; 5451da177e4SLinus Torvalds 5461da177e4SLinus Torvalds rd = jffs2_alloc_raw_dirent(); 5471da177e4SLinus Torvalds if (!rd) { 5481da177e4SLinus Torvalds /* Argh. Now we treat it like a normal delete */ 5491da177e4SLinus Torvalds jffs2_complete_reservation(c); 550f324e4cbSDavid Woodhouse ret = -ENOMEM; 551f324e4cbSDavid Woodhouse goto fail; 5521da177e4SLinus Torvalds } 5531da177e4SLinus Torvalds 5541da177e4SLinus Torvalds dir_f = JFFS2_INODE_INFO(dir_i); 555ced22070SDavid Woodhouse mutex_lock(&dir_f->sem); 5561da177e4SLinus Torvalds 5571da177e4SLinus Torvalds rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 5581da177e4SLinus Torvalds rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 5591da177e4SLinus Torvalds rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 5601da177e4SLinus Torvalds rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 5611da177e4SLinus Torvalds 5621da177e4SLinus Torvalds rd->pino = cpu_to_je32(dir_i->i_ino); 5631da177e4SLinus Torvalds rd->version = cpu_to_je32(++dir_f->highest_version); 5641da177e4SLinus Torvalds rd->ino = cpu_to_je32(inode->i_ino); 5651da177e4SLinus Torvalds rd->mctime = cpu_to_je32(get_seconds()); 5661da177e4SLinus Torvalds rd->nsize = namelen; 5671da177e4SLinus Torvalds rd->type = DT_DIR; 5681da177e4SLinus Torvalds rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 5691da177e4SLinus Torvalds rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen)); 5701da177e4SLinus Torvalds 5719fe4854cSDavid Woodhouse fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL); 5721da177e4SLinus Torvalds 5731da177e4SLinus Torvalds if (IS_ERR(fd)) { 5741da177e4SLinus Torvalds /* dirent failed to write. Delete the inode normally 5751da177e4SLinus Torvalds as if it were the final unlink() */ 5761da177e4SLinus Torvalds jffs2_complete_reservation(c); 5771da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 578ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 579f324e4cbSDavid Woodhouse ret = PTR_ERR(fd); 580f324e4cbSDavid Woodhouse goto fail; 5811da177e4SLinus Torvalds } 5821da177e4SLinus Torvalds 5831da177e4SLinus Torvalds dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime)); 584d8c76e6fSDave Hansen inc_nlink(dir_i); 5851da177e4SLinus Torvalds 5861da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 5871da177e4SLinus Torvalds 5881da177e4SLinus Torvalds /* Link the fd into the inode's list, obsoleting an old 5891da177e4SLinus Torvalds one if necessary. */ 5901da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &dir_f->dents); 5911da177e4SLinus Torvalds 592ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 5931da177e4SLinus Torvalds jffs2_complete_reservation(c); 5941da177e4SLinus Torvalds 5951da177e4SLinus Torvalds d_instantiate(dentry, inode); 596e72e6497SDavid Woodhouse unlock_new_inode(inode); 5971da177e4SLinus Torvalds return 0; 598f324e4cbSDavid Woodhouse 599f324e4cbSDavid Woodhouse fail: 60041cce647SAl Viro iget_failed(inode); 601f324e4cbSDavid Woodhouse return ret; 6021da177e4SLinus Torvalds } 6031da177e4SLinus Torvalds 6041da177e4SLinus Torvalds static int jffs2_rmdir (struct inode *dir_i, struct dentry *dentry) 6051da177e4SLinus Torvalds { 60627c72b04SDavid Woodhouse struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb); 60727c72b04SDavid Woodhouse struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); 6081da177e4SLinus Torvalds struct jffs2_inode_info *f = JFFS2_INODE_INFO(dentry->d_inode); 6091da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 6101da177e4SLinus Torvalds int ret; 61127c72b04SDavid Woodhouse uint32_t now = get_seconds(); 6121da177e4SLinus Torvalds 6131da177e4SLinus Torvalds for (fd = f->dents ; fd; fd = fd->next) { 6141da177e4SLinus Torvalds if (fd->ino) 6151da177e4SLinus Torvalds return -ENOTEMPTY; 6161da177e4SLinus Torvalds } 61727c72b04SDavid Woodhouse 61827c72b04SDavid Woodhouse ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name, 61927c72b04SDavid Woodhouse dentry->d_name.len, f, now); 62027c72b04SDavid Woodhouse if (!ret) { 62127c72b04SDavid Woodhouse dir_i->i_mtime = dir_i->i_ctime = ITIME(now); 62227c72b04SDavid Woodhouse clear_nlink(dentry->d_inode); 6239a53c3a7SDave Hansen drop_nlink(dir_i); 62427c72b04SDavid Woodhouse } 6251da177e4SLinus Torvalds return ret; 6261da177e4SLinus Torvalds } 6271da177e4SLinus Torvalds 628265489f0SDavid Woodhouse static int jffs2_mknod (struct inode *dir_i, struct dentry *dentry, int mode, dev_t rdev) 6291da177e4SLinus Torvalds { 6301da177e4SLinus Torvalds struct jffs2_inode_info *f, *dir_f; 6311da177e4SLinus Torvalds struct jffs2_sb_info *c; 6321da177e4SLinus Torvalds struct inode *inode; 6331da177e4SLinus Torvalds struct jffs2_raw_inode *ri; 6341da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 6351da177e4SLinus Torvalds struct jffs2_full_dnode *fn; 6361da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 6371da177e4SLinus Torvalds int namelen; 638aef9ab47SDavid Woodhouse union jffs2_device_node dev; 6391da177e4SLinus Torvalds int devlen = 0; 6409fe4854cSDavid Woodhouse uint32_t alloclen; 6411da177e4SLinus Torvalds int ret; 6421da177e4SLinus Torvalds 643aef9ab47SDavid Woodhouse if (!new_valid_dev(rdev)) 6441da177e4SLinus Torvalds return -EINVAL; 6451da177e4SLinus Torvalds 6461da177e4SLinus Torvalds ri = jffs2_alloc_raw_inode(); 6471da177e4SLinus Torvalds if (!ri) 6481da177e4SLinus Torvalds return -ENOMEM; 6491da177e4SLinus Torvalds 6501da177e4SLinus Torvalds c = JFFS2_SB_INFO(dir_i->i_sb); 6511da177e4SLinus Torvalds 652aef9ab47SDavid Woodhouse if (S_ISBLK(mode) || S_ISCHR(mode)) 653aef9ab47SDavid Woodhouse devlen = jffs2_encode_dev(&dev, rdev); 6541da177e4SLinus Torvalds 6551da177e4SLinus Torvalds /* Try to reserve enough space for both node and dirent. 6561da177e4SLinus Torvalds * Just the node will do for now, though 6571da177e4SLinus Torvalds */ 6581da177e4SLinus Torvalds namelen = dentry->d_name.len; 6599fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*ri) + devlen, &alloclen, 660e631ddbaSFerenc Havasi ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE); 6611da177e4SLinus Torvalds 6621da177e4SLinus Torvalds if (ret) { 6631da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 6641da177e4SLinus Torvalds return ret; 6651da177e4SLinus Torvalds } 6661da177e4SLinus Torvalds 667cfc8dc6fSKaiGai Kohei inode = jffs2_new_inode(dir_i, mode, ri); 6681da177e4SLinus Torvalds 6691da177e4SLinus Torvalds if (IS_ERR(inode)) { 6701da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 6711da177e4SLinus Torvalds jffs2_complete_reservation(c); 6721da177e4SLinus Torvalds return PTR_ERR(inode); 6731da177e4SLinus Torvalds } 6741da177e4SLinus Torvalds inode->i_op = &jffs2_file_inode_operations; 6751da177e4SLinus Torvalds init_special_inode(inode, inode->i_mode, rdev); 6761da177e4SLinus Torvalds 6771da177e4SLinus Torvalds f = JFFS2_INODE_INFO(inode); 6781da177e4SLinus Torvalds 6791da177e4SLinus Torvalds ri->dsize = ri->csize = cpu_to_je32(devlen); 6801da177e4SLinus Torvalds ri->totlen = cpu_to_je32(sizeof(*ri) + devlen); 6811da177e4SLinus Torvalds ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 6821da177e4SLinus Torvalds 6831da177e4SLinus Torvalds ri->compr = JFFS2_COMPR_NONE; 6841da177e4SLinus Torvalds ri->data_crc = cpu_to_je32(crc32(0, &dev, devlen)); 6851da177e4SLinus Torvalds ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 6861da177e4SLinus Torvalds 6879fe4854cSDavid Woodhouse fn = jffs2_write_dnode(c, f, ri, (char *)&dev, devlen, ALLOC_NORMAL); 6881da177e4SLinus Torvalds 6891da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 6901da177e4SLinus Torvalds 6911da177e4SLinus Torvalds if (IS_ERR(fn)) { 6921da177e4SLinus Torvalds /* Eeek. Wave bye bye */ 693ced22070SDavid Woodhouse mutex_unlock(&f->sem); 6941da177e4SLinus Torvalds jffs2_complete_reservation(c); 695f324e4cbSDavid Woodhouse ret = PTR_ERR(fn); 696f324e4cbSDavid Woodhouse goto fail; 6971da177e4SLinus Torvalds } 6981da177e4SLinus Torvalds /* No data here. Only a metadata node, which will be 6991da177e4SLinus Torvalds obsoleted by the first data write 7001da177e4SLinus Torvalds */ 7011da177e4SLinus Torvalds f->metadata = fn; 702ced22070SDavid Woodhouse mutex_unlock(&f->sem); 7031da177e4SLinus Torvalds 7041da177e4SLinus Torvalds jffs2_complete_reservation(c); 705aa98d7cfSKaiGai Kohei 706aa98d7cfSKaiGai Kohei ret = jffs2_init_security(inode, dir_i); 707f324e4cbSDavid Woodhouse if (ret) 708f324e4cbSDavid Woodhouse goto fail; 709f324e4cbSDavid Woodhouse 710cfc8dc6fSKaiGai Kohei ret = jffs2_init_acl_post(inode); 711f324e4cbSDavid Woodhouse if (ret) 712f324e4cbSDavid Woodhouse goto fail; 713aa98d7cfSKaiGai Kohei 7149fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 715e631ddbaSFerenc Havasi ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 716f324e4cbSDavid Woodhouse if (ret) 717f324e4cbSDavid Woodhouse goto fail; 7181da177e4SLinus Torvalds 7191da177e4SLinus Torvalds rd = jffs2_alloc_raw_dirent(); 7201da177e4SLinus Torvalds if (!rd) { 7211da177e4SLinus Torvalds /* Argh. Now we treat it like a normal delete */ 7221da177e4SLinus Torvalds jffs2_complete_reservation(c); 723f324e4cbSDavid Woodhouse ret = -ENOMEM; 724f324e4cbSDavid Woodhouse goto fail; 7251da177e4SLinus Torvalds } 7261da177e4SLinus Torvalds 7271da177e4SLinus Torvalds dir_f = JFFS2_INODE_INFO(dir_i); 728ced22070SDavid Woodhouse mutex_lock(&dir_f->sem); 7291da177e4SLinus Torvalds 7301da177e4SLinus Torvalds rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 7311da177e4SLinus Torvalds rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 7321da177e4SLinus Torvalds rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 7331da177e4SLinus Torvalds rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 7341da177e4SLinus Torvalds 7351da177e4SLinus Torvalds rd->pino = cpu_to_je32(dir_i->i_ino); 7361da177e4SLinus Torvalds rd->version = cpu_to_je32(++dir_f->highest_version); 7371da177e4SLinus Torvalds rd->ino = cpu_to_je32(inode->i_ino); 7381da177e4SLinus Torvalds rd->mctime = cpu_to_je32(get_seconds()); 7391da177e4SLinus Torvalds rd->nsize = namelen; 7401da177e4SLinus Torvalds 7411da177e4SLinus Torvalds /* XXX: This is ugly. */ 7421da177e4SLinus Torvalds rd->type = (mode & S_IFMT) >> 12; 7431da177e4SLinus Torvalds 7441da177e4SLinus Torvalds rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 7451da177e4SLinus Torvalds rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen)); 7461da177e4SLinus Torvalds 7479fe4854cSDavid Woodhouse fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL); 7481da177e4SLinus Torvalds 7491da177e4SLinus Torvalds if (IS_ERR(fd)) { 7501da177e4SLinus Torvalds /* dirent failed to write. Delete the inode normally 7511da177e4SLinus Torvalds as if it were the final unlink() */ 7521da177e4SLinus Torvalds jffs2_complete_reservation(c); 7531da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 754ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 755f324e4cbSDavid Woodhouse ret = PTR_ERR(fd); 756f324e4cbSDavid Woodhouse goto fail; 7571da177e4SLinus Torvalds } 7581da177e4SLinus Torvalds 7591da177e4SLinus Torvalds dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime)); 7601da177e4SLinus Torvalds 7611da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 7621da177e4SLinus Torvalds 7631da177e4SLinus Torvalds /* Link the fd into the inode's list, obsoleting an old 7641da177e4SLinus Torvalds one if necessary. */ 7651da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &dir_f->dents); 7661da177e4SLinus Torvalds 767ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 7681da177e4SLinus Torvalds jffs2_complete_reservation(c); 7691da177e4SLinus Torvalds 7701da177e4SLinus Torvalds d_instantiate(dentry, inode); 771e72e6497SDavid Woodhouse unlock_new_inode(inode); 7721da177e4SLinus Torvalds return 0; 773f324e4cbSDavid Woodhouse 774f324e4cbSDavid Woodhouse fail: 77541cce647SAl Viro iget_failed(inode); 776f324e4cbSDavid Woodhouse return ret; 7771da177e4SLinus Torvalds } 7781da177e4SLinus Torvalds 7791da177e4SLinus Torvalds static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry, 7801da177e4SLinus Torvalds struct inode *new_dir_i, struct dentry *new_dentry) 7811da177e4SLinus Torvalds { 7821da177e4SLinus Torvalds int ret; 7831da177e4SLinus Torvalds struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dir_i->i_sb); 7841da177e4SLinus Torvalds struct jffs2_inode_info *victim_f = NULL; 7851da177e4SLinus Torvalds uint8_t type; 7863a69e0cdSArtem B. Bityutskiy uint32_t now; 7871da177e4SLinus Torvalds 7881da177e4SLinus Torvalds /* The VFS will check for us and prevent trying to rename a 7891da177e4SLinus Torvalds * file over a directory and vice versa, but if it's a directory, 7901da177e4SLinus Torvalds * the VFS can't check whether the victim is empty. The filesystem 7911da177e4SLinus Torvalds * needs to do that for itself. 7921da177e4SLinus Torvalds */ 7931da177e4SLinus Torvalds if (new_dentry->d_inode) { 7941da177e4SLinus Torvalds victim_f = JFFS2_INODE_INFO(new_dentry->d_inode); 7951da177e4SLinus Torvalds if (S_ISDIR(new_dentry->d_inode->i_mode)) { 7961da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 7971da177e4SLinus Torvalds 798ced22070SDavid Woodhouse mutex_lock(&victim_f->sem); 7991da177e4SLinus Torvalds for (fd = victim_f->dents; fd; fd = fd->next) { 8001da177e4SLinus Torvalds if (fd->ino) { 801ced22070SDavid Woodhouse mutex_unlock(&victim_f->sem); 8021da177e4SLinus Torvalds return -ENOTEMPTY; 8031da177e4SLinus Torvalds } 8041da177e4SLinus Torvalds } 805ced22070SDavid Woodhouse mutex_unlock(&victim_f->sem); 8061da177e4SLinus Torvalds } 8071da177e4SLinus Torvalds } 8081da177e4SLinus Torvalds 8091da177e4SLinus Torvalds /* XXX: We probably ought to alloc enough space for 8101da177e4SLinus Torvalds both nodes at the same time. Writing the new link, 8111da177e4SLinus Torvalds then getting -ENOSPC, is quite bad :) 8121da177e4SLinus Torvalds */ 8131da177e4SLinus Torvalds 8141da177e4SLinus Torvalds /* Make a hard link */ 8151da177e4SLinus Torvalds 8161da177e4SLinus Torvalds /* XXX: This is ugly */ 8171da177e4SLinus Torvalds type = (old_dentry->d_inode->i_mode & S_IFMT) >> 12; 8181da177e4SLinus Torvalds if (!type) type = DT_REG; 8191da177e4SLinus Torvalds 8203a69e0cdSArtem B. Bityutskiy now = get_seconds(); 8211da177e4SLinus Torvalds ret = jffs2_do_link(c, JFFS2_INODE_INFO(new_dir_i), 8221da177e4SLinus Torvalds old_dentry->d_inode->i_ino, type, 8233a69e0cdSArtem B. Bityutskiy new_dentry->d_name.name, new_dentry->d_name.len, now); 8241da177e4SLinus Torvalds 8251da177e4SLinus Torvalds if (ret) 8261da177e4SLinus Torvalds return ret; 8271da177e4SLinus Torvalds 8281da177e4SLinus Torvalds if (victim_f) { 8291da177e4SLinus Torvalds /* There was a victim. Kill it off nicely */ 8309a53c3a7SDave Hansen drop_nlink(new_dentry->d_inode); 8311da177e4SLinus Torvalds /* Don't oops if the victim was a dirent pointing to an 8321da177e4SLinus Torvalds inode which didn't exist. */ 8331da177e4SLinus Torvalds if (victim_f->inocache) { 834ced22070SDavid Woodhouse mutex_lock(&victim_f->sem); 83527c72b04SDavid Woodhouse if (S_ISDIR(new_dentry->d_inode->i_mode)) 83627c72b04SDavid Woodhouse victim_f->inocache->pino_nlink = 0; 83727c72b04SDavid Woodhouse else 83827c72b04SDavid Woodhouse victim_f->inocache->pino_nlink--; 839ced22070SDavid Woodhouse mutex_unlock(&victim_f->sem); 8401da177e4SLinus Torvalds } 8411da177e4SLinus Torvalds } 8421da177e4SLinus Torvalds 8431da177e4SLinus Torvalds /* If it was a directory we moved, and there was no victim, 8441da177e4SLinus Torvalds increase i_nlink on its new parent */ 8451da177e4SLinus Torvalds if (S_ISDIR(old_dentry->d_inode->i_mode) && !victim_f) 846d8c76e6fSDave Hansen inc_nlink(new_dir_i); 8471da177e4SLinus Torvalds 8481da177e4SLinus Torvalds /* Unlink the original */ 8491da177e4SLinus Torvalds ret = jffs2_do_unlink(c, JFFS2_INODE_INFO(old_dir_i), 8503a69e0cdSArtem B. Bityutskiy old_dentry->d_name.name, old_dentry->d_name.len, NULL, now); 8511da177e4SLinus Torvalds 8521da177e4SLinus Torvalds /* We don't touch inode->i_nlink */ 8531da177e4SLinus Torvalds 8541da177e4SLinus Torvalds if (ret) { 8551da177e4SLinus Torvalds /* Oh shit. We really ought to make a single node which can do both atomically */ 8561da177e4SLinus Torvalds struct jffs2_inode_info *f = JFFS2_INODE_INFO(old_dentry->d_inode); 857ced22070SDavid Woodhouse mutex_lock(&f->sem); 858d8c76e6fSDave Hansen inc_nlink(old_dentry->d_inode); 85927c72b04SDavid Woodhouse if (f->inocache && !S_ISDIR(old_dentry->d_inode->i_mode)) 86027c72b04SDavid Woodhouse f->inocache->pino_nlink++; 861ced22070SDavid Woodhouse mutex_unlock(&f->sem); 8621da177e4SLinus Torvalds 8631da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_rename(): Link succeeded, unlink failed (err %d). You now have a hard link\n", ret); 8641da177e4SLinus Torvalds /* Might as well let the VFS know */ 8651da177e4SLinus Torvalds d_instantiate(new_dentry, old_dentry->d_inode); 8661da177e4SLinus Torvalds atomic_inc(&old_dentry->d_inode->i_count); 8673a69e0cdSArtem B. Bityutskiy new_dir_i->i_mtime = new_dir_i->i_ctime = ITIME(now); 8681da177e4SLinus Torvalds return ret; 8691da177e4SLinus Torvalds } 8701da177e4SLinus Torvalds 8711da177e4SLinus Torvalds if (S_ISDIR(old_dentry->d_inode->i_mode)) 8729a53c3a7SDave Hansen drop_nlink(old_dir_i); 8731da177e4SLinus Torvalds 8743a69e0cdSArtem B. Bityutskiy new_dir_i->i_mtime = new_dir_i->i_ctime = old_dir_i->i_mtime = old_dir_i->i_ctime = ITIME(now); 8753a69e0cdSArtem B. Bityutskiy 8761da177e4SLinus Torvalds return 0; 8771da177e4SLinus Torvalds } 8781da177e4SLinus Torvalds 879