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 * 101da177e4SLinus Torvalds * $Id: dir.c,v 1.84 2004/11/16 20:36:11 dwmw2 Exp $ 111da177e4SLinus Torvalds * 121da177e4SLinus Torvalds */ 131da177e4SLinus Torvalds 141da177e4SLinus Torvalds #include <linux/kernel.h> 151da177e4SLinus Torvalds #include <linux/slab.h> 161da177e4SLinus Torvalds #include <linux/sched.h> 171da177e4SLinus Torvalds #include <linux/fs.h> 181da177e4SLinus Torvalds #include <linux/crc32.h> 191da177e4SLinus Torvalds #include <linux/jffs2.h> 201da177e4SLinus Torvalds #include <linux/jffs2_fs_i.h> 211da177e4SLinus Torvalds #include <linux/jffs2_fs_sb.h> 221da177e4SLinus Torvalds #include <linux/time.h> 231da177e4SLinus Torvalds #include "nodelist.h" 241da177e4SLinus Torvalds 251da177e4SLinus Torvalds /* Urgh. Please tell me there's a nicer way of doing these. */ 261da177e4SLinus Torvalds #include <linux/version.h> 271da177e4SLinus Torvalds #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,48) 281da177e4SLinus Torvalds typedef int mknod_arg_t; 291da177e4SLinus Torvalds #define NAMEI_COMPAT(x) ((void *)x) 301da177e4SLinus Torvalds #else 311da177e4SLinus Torvalds typedef dev_t mknod_arg_t; 321da177e4SLinus Torvalds #define NAMEI_COMPAT(x) (x) 331da177e4SLinus Torvalds #endif 341da177e4SLinus Torvalds 351da177e4SLinus Torvalds static int jffs2_readdir (struct file *, void *, filldir_t); 361da177e4SLinus Torvalds 371da177e4SLinus Torvalds static int jffs2_create (struct inode *,struct dentry *,int, 381da177e4SLinus Torvalds struct nameidata *); 391da177e4SLinus Torvalds static struct dentry *jffs2_lookup (struct inode *,struct dentry *, 401da177e4SLinus Torvalds struct nameidata *); 411da177e4SLinus Torvalds static int jffs2_link (struct dentry *,struct inode *,struct dentry *); 421da177e4SLinus Torvalds static int jffs2_unlink (struct inode *,struct dentry *); 431da177e4SLinus Torvalds static int jffs2_symlink (struct inode *,struct dentry *,const char *); 441da177e4SLinus Torvalds static int jffs2_mkdir (struct inode *,struct dentry *,int); 451da177e4SLinus Torvalds static int jffs2_rmdir (struct inode *,struct dentry *); 461da177e4SLinus Torvalds static int jffs2_mknod (struct inode *,struct dentry *,int,mknod_arg_t); 471da177e4SLinus Torvalds static int jffs2_rename (struct inode *, struct dentry *, 481da177e4SLinus Torvalds struct inode *, struct dentry *); 491da177e4SLinus Torvalds 501da177e4SLinus Torvalds struct file_operations jffs2_dir_operations = 511da177e4SLinus Torvalds { 521da177e4SLinus Torvalds .read = generic_read_dir, 531da177e4SLinus Torvalds .readdir = jffs2_readdir, 541da177e4SLinus Torvalds .ioctl = jffs2_ioctl, 551da177e4SLinus Torvalds .fsync = jffs2_fsync 561da177e4SLinus Torvalds }; 571da177e4SLinus Torvalds 581da177e4SLinus Torvalds 591da177e4SLinus Torvalds struct inode_operations jffs2_dir_inode_operations = 601da177e4SLinus Torvalds { 611da177e4SLinus Torvalds .create = NAMEI_COMPAT(jffs2_create), 621da177e4SLinus Torvalds .lookup = NAMEI_COMPAT(jffs2_lookup), 631da177e4SLinus Torvalds .link = jffs2_link, 641da177e4SLinus Torvalds .unlink = jffs2_unlink, 651da177e4SLinus Torvalds .symlink = jffs2_symlink, 661da177e4SLinus Torvalds .mkdir = jffs2_mkdir, 671da177e4SLinus Torvalds .rmdir = jffs2_rmdir, 681da177e4SLinus Torvalds .mknod = jffs2_mknod, 691da177e4SLinus Torvalds .rename = jffs2_rename, 701da177e4SLinus Torvalds .setattr = jffs2_setattr, 711da177e4SLinus Torvalds }; 721da177e4SLinus Torvalds 731da177e4SLinus Torvalds /***********************************************************************/ 741da177e4SLinus Torvalds 751da177e4SLinus Torvalds 761da177e4SLinus Torvalds /* We keep the dirent list sorted in increasing order of name hash, 771da177e4SLinus Torvalds and we use the same hash function as the dentries. Makes this 781da177e4SLinus Torvalds nice and simple 791da177e4SLinus Torvalds */ 801da177e4SLinus Torvalds static struct dentry *jffs2_lookup(struct inode *dir_i, struct dentry *target, 811da177e4SLinus Torvalds struct nameidata *nd) 821da177e4SLinus Torvalds { 831da177e4SLinus Torvalds struct jffs2_inode_info *dir_f; 841da177e4SLinus Torvalds struct jffs2_sb_info *c; 851da177e4SLinus Torvalds struct jffs2_full_dirent *fd = NULL, *fd_list; 861da177e4SLinus Torvalds uint32_t ino = 0; 871da177e4SLinus Torvalds struct inode *inode = NULL; 881da177e4SLinus Torvalds 891da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_lookup()\n")); 901da177e4SLinus Torvalds 911da177e4SLinus Torvalds dir_f = JFFS2_INODE_INFO(dir_i); 921da177e4SLinus Torvalds c = JFFS2_SB_INFO(dir_i->i_sb); 931da177e4SLinus Torvalds 941da177e4SLinus Torvalds down(&dir_f->sem); 951da177e4SLinus Torvalds 961da177e4SLinus Torvalds /* NB: The 2.2 backport will need to explicitly check for '.' and '..' here */ 971da177e4SLinus Torvalds for (fd_list = dir_f->dents; fd_list && fd_list->nhash <= target->d_name.hash; fd_list = fd_list->next) { 981da177e4SLinus Torvalds if (fd_list->nhash == target->d_name.hash && 991da177e4SLinus Torvalds (!fd || fd_list->version > fd->version) && 1001da177e4SLinus Torvalds strlen(fd_list->name) == target->d_name.len && 1011da177e4SLinus Torvalds !strncmp(fd_list->name, target->d_name.name, target->d_name.len)) { 1021da177e4SLinus Torvalds fd = fd_list; 1031da177e4SLinus Torvalds } 1041da177e4SLinus Torvalds } 1051da177e4SLinus Torvalds if (fd) 1061da177e4SLinus Torvalds ino = fd->ino; 1071da177e4SLinus Torvalds up(&dir_f->sem); 1081da177e4SLinus Torvalds if (ino) { 1091da177e4SLinus Torvalds inode = iget(dir_i->i_sb, ino); 1101da177e4SLinus Torvalds if (!inode) { 1111da177e4SLinus Torvalds printk(KERN_WARNING "iget() failed for ino #%u\n", ino); 1121da177e4SLinus Torvalds return (ERR_PTR(-EIO)); 1131da177e4SLinus Torvalds } 1141da177e4SLinus Torvalds } 1151da177e4SLinus Torvalds 1161da177e4SLinus Torvalds d_add(target, inode); 1171da177e4SLinus Torvalds 1181da177e4SLinus Torvalds return NULL; 1191da177e4SLinus Torvalds } 1201da177e4SLinus Torvalds 1211da177e4SLinus Torvalds /***********************************************************************/ 1221da177e4SLinus Torvalds 1231da177e4SLinus Torvalds 1241da177e4SLinus Torvalds static int jffs2_readdir(struct file *filp, void *dirent, filldir_t filldir) 1251da177e4SLinus Torvalds { 1261da177e4SLinus Torvalds struct jffs2_inode_info *f; 1271da177e4SLinus Torvalds struct jffs2_sb_info *c; 1281da177e4SLinus Torvalds struct inode *inode = filp->f_dentry->d_inode; 1291da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 1301da177e4SLinus Torvalds unsigned long offset, curofs; 1311da177e4SLinus Torvalds 1321da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_readdir() for dir_i #%lu\n", filp->f_dentry->d_inode->i_ino)); 1331da177e4SLinus Torvalds 1341da177e4SLinus Torvalds f = JFFS2_INODE_INFO(inode); 1351da177e4SLinus Torvalds c = JFFS2_SB_INFO(inode->i_sb); 1361da177e4SLinus Torvalds 1371da177e4SLinus Torvalds offset = filp->f_pos; 1381da177e4SLinus Torvalds 1391da177e4SLinus Torvalds if (offset == 0) { 1401da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Dirent 0: \".\", ino #%lu\n", inode->i_ino)); 1411da177e4SLinus Torvalds if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR) < 0) 1421da177e4SLinus Torvalds goto out; 1431da177e4SLinus Torvalds offset++; 1441da177e4SLinus Torvalds } 1451da177e4SLinus Torvalds if (offset == 1) { 1461da177e4SLinus Torvalds unsigned long pino = parent_ino(filp->f_dentry); 1471da177e4SLinus Torvalds D1(printk(KERN_DEBUG "Dirent 1: \"..\", ino #%lu\n", pino)); 1481da177e4SLinus Torvalds if (filldir(dirent, "..", 2, 1, pino, DT_DIR) < 0) 1491da177e4SLinus Torvalds goto out; 1501da177e4SLinus Torvalds offset++; 1511da177e4SLinus Torvalds } 1521da177e4SLinus Torvalds 1531da177e4SLinus Torvalds curofs=1; 1541da177e4SLinus Torvalds down(&f->sem); 1551da177e4SLinus Torvalds for (fd = f->dents; fd; fd = fd->next) { 1561da177e4SLinus Torvalds 1571da177e4SLinus Torvalds curofs++; 1581da177e4SLinus Torvalds /* First loop: curofs = 2; offset = 2 */ 1591da177e4SLinus Torvalds if (curofs < offset) { 1601da177e4SLinus Torvalds D2(printk(KERN_DEBUG "Skipping dirent: \"%s\", ino #%u, type %d, because curofs %ld < offset %ld\n", 1611da177e4SLinus Torvalds fd->name, fd->ino, fd->type, curofs, offset)); 1621da177e4SLinus Torvalds continue; 1631da177e4SLinus Torvalds } 1641da177e4SLinus Torvalds if (!fd->ino) { 1651da177e4SLinus Torvalds D2(printk(KERN_DEBUG "Skipping deletion dirent \"%s\"\n", fd->name)); 1661da177e4SLinus Torvalds offset++; 1671da177e4SLinus Torvalds continue; 1681da177e4SLinus Torvalds } 1691da177e4SLinus Torvalds D2(printk(KERN_DEBUG "Dirent %ld: \"%s\", ino #%u, type %d\n", offset, fd->name, fd->ino, fd->type)); 1701da177e4SLinus Torvalds if (filldir(dirent, fd->name, strlen(fd->name), offset, fd->ino, fd->type) < 0) 1711da177e4SLinus Torvalds break; 1721da177e4SLinus Torvalds offset++; 1731da177e4SLinus Torvalds } 1741da177e4SLinus Torvalds up(&f->sem); 1751da177e4SLinus Torvalds out: 1761da177e4SLinus Torvalds filp->f_pos = offset; 1771da177e4SLinus Torvalds return 0; 1781da177e4SLinus Torvalds } 1791da177e4SLinus Torvalds 1801da177e4SLinus Torvalds /***********************************************************************/ 1811da177e4SLinus Torvalds 1821da177e4SLinus Torvalds 1831da177e4SLinus Torvalds static int jffs2_create(struct inode *dir_i, struct dentry *dentry, int mode, 1841da177e4SLinus Torvalds struct nameidata *nd) 1851da177e4SLinus Torvalds { 1861da177e4SLinus Torvalds struct jffs2_raw_inode *ri; 1871da177e4SLinus Torvalds struct jffs2_inode_info *f, *dir_f; 1881da177e4SLinus Torvalds struct jffs2_sb_info *c; 1891da177e4SLinus Torvalds struct inode *inode; 1901da177e4SLinus Torvalds int ret; 1911da177e4SLinus Torvalds 1921da177e4SLinus Torvalds ri = jffs2_alloc_raw_inode(); 1931da177e4SLinus Torvalds if (!ri) 1941da177e4SLinus Torvalds return -ENOMEM; 1951da177e4SLinus Torvalds 1961da177e4SLinus Torvalds c = JFFS2_SB_INFO(dir_i->i_sb); 1971da177e4SLinus Torvalds 1981da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_create()\n")); 1991da177e4SLinus Torvalds 2001da177e4SLinus Torvalds inode = jffs2_new_inode(dir_i, mode, ri); 2011da177e4SLinus Torvalds 2021da177e4SLinus Torvalds if (IS_ERR(inode)) { 2031da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_new_inode() failed\n")); 2041da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 2051da177e4SLinus Torvalds return PTR_ERR(inode); 2061da177e4SLinus Torvalds } 2071da177e4SLinus Torvalds 2081da177e4SLinus Torvalds inode->i_op = &jffs2_file_inode_operations; 2091da177e4SLinus Torvalds inode->i_fop = &jffs2_file_operations; 2101da177e4SLinus Torvalds inode->i_mapping->a_ops = &jffs2_file_address_operations; 2111da177e4SLinus Torvalds inode->i_mapping->nrpages = 0; 2121da177e4SLinus Torvalds 2131da177e4SLinus Torvalds f = JFFS2_INODE_INFO(inode); 2141da177e4SLinus Torvalds dir_f = JFFS2_INODE_INFO(dir_i); 2151da177e4SLinus Torvalds 2161da177e4SLinus Torvalds ret = jffs2_do_create(c, dir_f, f, ri, 2171da177e4SLinus Torvalds dentry->d_name.name, dentry->d_name.len); 2181da177e4SLinus Torvalds 2191da177e4SLinus Torvalds if (ret) { 2201da177e4SLinus Torvalds make_bad_inode(inode); 2211da177e4SLinus Torvalds iput(inode); 2221da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 2231da177e4SLinus Torvalds return ret; 2241da177e4SLinus Torvalds } 2251da177e4SLinus Torvalds 2261da177e4SLinus Torvalds dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(ri->ctime)); 2271da177e4SLinus Torvalds 2281da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 2291da177e4SLinus Torvalds d_instantiate(dentry, inode); 2301da177e4SLinus Torvalds 2311da177e4SLinus Torvalds D1(printk(KERN_DEBUG "jffs2_create: Created ino #%lu with mode %o, nlink %d(%d). nrpages %ld\n", 2321da177e4SLinus Torvalds inode->i_ino, inode->i_mode, inode->i_nlink, f->inocache->nlink, inode->i_mapping->nrpages)); 2331da177e4SLinus Torvalds return 0; 2341da177e4SLinus Torvalds } 2351da177e4SLinus Torvalds 2361da177e4SLinus Torvalds /***********************************************************************/ 2371da177e4SLinus Torvalds 2381da177e4SLinus Torvalds 2391da177e4SLinus Torvalds static int jffs2_unlink(struct inode *dir_i, struct dentry *dentry) 2401da177e4SLinus Torvalds { 2411da177e4SLinus Torvalds struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb); 2421da177e4SLinus Torvalds struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); 2431da177e4SLinus Torvalds struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(dentry->d_inode); 2441da177e4SLinus Torvalds int ret; 2451da177e4SLinus Torvalds 2461da177e4SLinus Torvalds ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name, 2471da177e4SLinus Torvalds dentry->d_name.len, dead_f); 2481da177e4SLinus Torvalds if (dead_f->inocache) 2491da177e4SLinus Torvalds dentry->d_inode->i_nlink = dead_f->inocache->nlink; 2501da177e4SLinus Torvalds return ret; 2511da177e4SLinus Torvalds } 2521da177e4SLinus Torvalds /***********************************************************************/ 2531da177e4SLinus Torvalds 2541da177e4SLinus Torvalds 2551da177e4SLinus Torvalds static int jffs2_link (struct dentry *old_dentry, struct inode *dir_i, struct dentry *dentry) 2561da177e4SLinus Torvalds { 2571da177e4SLinus Torvalds struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dentry->d_inode->i_sb); 2581da177e4SLinus Torvalds struct jffs2_inode_info *f = JFFS2_INODE_INFO(old_dentry->d_inode); 2591da177e4SLinus Torvalds struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); 2601da177e4SLinus Torvalds int ret; 2611da177e4SLinus Torvalds uint8_t type; 2621da177e4SLinus Torvalds 2631da177e4SLinus Torvalds /* Don't let people make hard links to bad inodes. */ 2641da177e4SLinus Torvalds if (!f->inocache) 2651da177e4SLinus Torvalds return -EIO; 2661da177e4SLinus Torvalds 2671da177e4SLinus Torvalds if (S_ISDIR(old_dentry->d_inode->i_mode)) 2681da177e4SLinus Torvalds return -EPERM; 2691da177e4SLinus Torvalds 2701da177e4SLinus Torvalds /* XXX: This is ugly */ 2711da177e4SLinus Torvalds type = (old_dentry->d_inode->i_mode & S_IFMT) >> 12; 2721da177e4SLinus Torvalds if (!type) type = DT_REG; 2731da177e4SLinus Torvalds 2741da177e4SLinus Torvalds ret = jffs2_do_link(c, dir_f, f->inocache->ino, type, dentry->d_name.name, dentry->d_name.len); 2751da177e4SLinus Torvalds 2761da177e4SLinus Torvalds if (!ret) { 2771da177e4SLinus Torvalds down(&f->sem); 2781da177e4SLinus Torvalds old_dentry->d_inode->i_nlink = ++f->inocache->nlink; 2791da177e4SLinus Torvalds up(&f->sem); 2801da177e4SLinus Torvalds d_instantiate(dentry, old_dentry->d_inode); 2811da177e4SLinus Torvalds atomic_inc(&old_dentry->d_inode->i_count); 2821da177e4SLinus Torvalds } 2831da177e4SLinus Torvalds return ret; 2841da177e4SLinus Torvalds } 2851da177e4SLinus Torvalds 2861da177e4SLinus Torvalds /***********************************************************************/ 2871da177e4SLinus Torvalds 2881da177e4SLinus Torvalds static int jffs2_symlink (struct inode *dir_i, struct dentry *dentry, const char *target) 2891da177e4SLinus Torvalds { 2901da177e4SLinus Torvalds struct jffs2_inode_info *f, *dir_f; 2911da177e4SLinus Torvalds struct jffs2_sb_info *c; 2921da177e4SLinus Torvalds struct inode *inode; 2931da177e4SLinus Torvalds struct jffs2_raw_inode *ri; 2941da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 2951da177e4SLinus Torvalds struct jffs2_full_dnode *fn; 2961da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 2971da177e4SLinus Torvalds int namelen; 2981da177e4SLinus Torvalds uint32_t alloclen, phys_ofs; 2991da177e4SLinus Torvalds int ret; 3001da177e4SLinus Torvalds 3011da177e4SLinus Torvalds /* FIXME: If you care. We'd need to use frags for the target 3021da177e4SLinus Torvalds if it grows much more than this */ 3031da177e4SLinus Torvalds if (strlen(target) > 254) 3041da177e4SLinus Torvalds return -EINVAL; 3051da177e4SLinus Torvalds 3061da177e4SLinus Torvalds ri = jffs2_alloc_raw_inode(); 3071da177e4SLinus Torvalds 3081da177e4SLinus Torvalds if (!ri) 3091da177e4SLinus Torvalds return -ENOMEM; 3101da177e4SLinus Torvalds 3111da177e4SLinus Torvalds c = JFFS2_SB_INFO(dir_i->i_sb); 3121da177e4SLinus Torvalds 3131da177e4SLinus Torvalds /* Try to reserve enough space for both node and dirent. 3141da177e4SLinus Torvalds * Just the node will do for now, though 3151da177e4SLinus Torvalds */ 3161da177e4SLinus Torvalds namelen = dentry->d_name.len; 3171da177e4SLinus Torvalds ret = jffs2_reserve_space(c, sizeof(*ri) + strlen(target), &phys_ofs, &alloclen, ALLOC_NORMAL); 3181da177e4SLinus Torvalds 3191da177e4SLinus Torvalds if (ret) { 3201da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 3211da177e4SLinus Torvalds return ret; 3221da177e4SLinus Torvalds } 3231da177e4SLinus Torvalds 3241da177e4SLinus Torvalds inode = jffs2_new_inode(dir_i, S_IFLNK | S_IRWXUGO, ri); 3251da177e4SLinus Torvalds 3261da177e4SLinus Torvalds if (IS_ERR(inode)) { 3271da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 3281da177e4SLinus Torvalds jffs2_complete_reservation(c); 3291da177e4SLinus Torvalds return PTR_ERR(inode); 3301da177e4SLinus Torvalds } 3311da177e4SLinus Torvalds 3321da177e4SLinus Torvalds inode->i_op = &jffs2_symlink_inode_operations; 3331da177e4SLinus Torvalds 3341da177e4SLinus Torvalds f = JFFS2_INODE_INFO(inode); 3351da177e4SLinus Torvalds 3361da177e4SLinus Torvalds inode->i_size = strlen(target); 3371da177e4SLinus Torvalds ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size); 3381da177e4SLinus Torvalds ri->totlen = cpu_to_je32(sizeof(*ri) + inode->i_size); 3391da177e4SLinus Torvalds ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 3401da177e4SLinus Torvalds 3411da177e4SLinus Torvalds ri->compr = JFFS2_COMPR_NONE; 3421da177e4SLinus Torvalds ri->data_crc = cpu_to_je32(crc32(0, target, strlen(target))); 3431da177e4SLinus Torvalds ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 3441da177e4SLinus Torvalds 3451da177e4SLinus Torvalds fn = jffs2_write_dnode(c, f, ri, target, strlen(target), phys_ofs, ALLOC_NORMAL); 3461da177e4SLinus Torvalds 3471da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 3481da177e4SLinus Torvalds 3491da177e4SLinus Torvalds if (IS_ERR(fn)) { 3501da177e4SLinus Torvalds /* Eeek. Wave bye bye */ 3511da177e4SLinus Torvalds up(&f->sem); 3521da177e4SLinus Torvalds jffs2_complete_reservation(c); 3531da177e4SLinus Torvalds jffs2_clear_inode(inode); 3541da177e4SLinus Torvalds return PTR_ERR(fn); 3551da177e4SLinus Torvalds } 3561da177e4SLinus Torvalds /* No data here. Only a metadata node, which will be 3571da177e4SLinus Torvalds obsoleted by the first data write 3581da177e4SLinus Torvalds */ 3591da177e4SLinus Torvalds f->metadata = fn; 3601da177e4SLinus Torvalds up(&f->sem); 3611da177e4SLinus Torvalds 3621da177e4SLinus Torvalds jffs2_complete_reservation(c); 3631da177e4SLinus Torvalds ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen, ALLOC_NORMAL); 3641da177e4SLinus Torvalds if (ret) { 3651da177e4SLinus Torvalds /* Eep. */ 3661da177e4SLinus Torvalds jffs2_clear_inode(inode); 3671da177e4SLinus Torvalds return ret; 3681da177e4SLinus Torvalds } 3691da177e4SLinus Torvalds 3701da177e4SLinus Torvalds rd = jffs2_alloc_raw_dirent(); 3711da177e4SLinus Torvalds if (!rd) { 3721da177e4SLinus Torvalds /* Argh. Now we treat it like a normal delete */ 3731da177e4SLinus Torvalds jffs2_complete_reservation(c); 3741da177e4SLinus Torvalds jffs2_clear_inode(inode); 3751da177e4SLinus Torvalds return -ENOMEM; 3761da177e4SLinus Torvalds } 3771da177e4SLinus Torvalds 3781da177e4SLinus Torvalds dir_f = JFFS2_INODE_INFO(dir_i); 3791da177e4SLinus Torvalds down(&dir_f->sem); 3801da177e4SLinus Torvalds 3811da177e4SLinus Torvalds rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 3821da177e4SLinus Torvalds rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 3831da177e4SLinus Torvalds rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 3841da177e4SLinus Torvalds rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 3851da177e4SLinus Torvalds 3861da177e4SLinus Torvalds rd->pino = cpu_to_je32(dir_i->i_ino); 3871da177e4SLinus Torvalds rd->version = cpu_to_je32(++dir_f->highest_version); 3881da177e4SLinus Torvalds rd->ino = cpu_to_je32(inode->i_ino); 3891da177e4SLinus Torvalds rd->mctime = cpu_to_je32(get_seconds()); 3901da177e4SLinus Torvalds rd->nsize = namelen; 3911da177e4SLinus Torvalds rd->type = DT_LNK; 3921da177e4SLinus Torvalds rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 3931da177e4SLinus Torvalds rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen)); 3941da177e4SLinus Torvalds 3951da177e4SLinus Torvalds fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, phys_ofs, ALLOC_NORMAL); 3961da177e4SLinus Torvalds 3971da177e4SLinus Torvalds if (IS_ERR(fd)) { 3981da177e4SLinus Torvalds /* dirent failed to write. Delete the inode normally 3991da177e4SLinus Torvalds as if it were the final unlink() */ 4001da177e4SLinus Torvalds jffs2_complete_reservation(c); 4011da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 4021da177e4SLinus Torvalds up(&dir_f->sem); 4031da177e4SLinus Torvalds jffs2_clear_inode(inode); 4041da177e4SLinus Torvalds return PTR_ERR(fd); 4051da177e4SLinus Torvalds } 4061da177e4SLinus Torvalds 4071da177e4SLinus Torvalds dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime)); 4081da177e4SLinus Torvalds 4091da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 4101da177e4SLinus Torvalds 4111da177e4SLinus Torvalds /* Link the fd into the inode's list, obsoleting an old 4121da177e4SLinus Torvalds one if necessary. */ 4131da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &dir_f->dents); 4141da177e4SLinus Torvalds 4151da177e4SLinus Torvalds up(&dir_f->sem); 4161da177e4SLinus Torvalds jffs2_complete_reservation(c); 4171da177e4SLinus Torvalds 4181da177e4SLinus Torvalds d_instantiate(dentry, inode); 4191da177e4SLinus Torvalds return 0; 4201da177e4SLinus Torvalds } 4211da177e4SLinus Torvalds 4221da177e4SLinus Torvalds 4231da177e4SLinus Torvalds static int jffs2_mkdir (struct inode *dir_i, struct dentry *dentry, int mode) 4241da177e4SLinus Torvalds { 4251da177e4SLinus Torvalds struct jffs2_inode_info *f, *dir_f; 4261da177e4SLinus Torvalds struct jffs2_sb_info *c; 4271da177e4SLinus Torvalds struct inode *inode; 4281da177e4SLinus Torvalds struct jffs2_raw_inode *ri; 4291da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 4301da177e4SLinus Torvalds struct jffs2_full_dnode *fn; 4311da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 4321da177e4SLinus Torvalds int namelen; 4331da177e4SLinus Torvalds uint32_t alloclen, phys_ofs; 4341da177e4SLinus Torvalds int ret; 4351da177e4SLinus Torvalds 4361da177e4SLinus Torvalds mode |= S_IFDIR; 4371da177e4SLinus Torvalds 4381da177e4SLinus Torvalds ri = jffs2_alloc_raw_inode(); 4391da177e4SLinus Torvalds if (!ri) 4401da177e4SLinus Torvalds return -ENOMEM; 4411da177e4SLinus Torvalds 4421da177e4SLinus Torvalds c = JFFS2_SB_INFO(dir_i->i_sb); 4431da177e4SLinus Torvalds 4441da177e4SLinus Torvalds /* Try to reserve enough space for both node and dirent. 4451da177e4SLinus Torvalds * Just the node will do for now, though 4461da177e4SLinus Torvalds */ 4471da177e4SLinus Torvalds namelen = dentry->d_name.len; 4481da177e4SLinus Torvalds ret = jffs2_reserve_space(c, sizeof(*ri), &phys_ofs, &alloclen, ALLOC_NORMAL); 4491da177e4SLinus Torvalds 4501da177e4SLinus Torvalds if (ret) { 4511da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 4521da177e4SLinus Torvalds return ret; 4531da177e4SLinus Torvalds } 4541da177e4SLinus Torvalds 4551da177e4SLinus Torvalds inode = jffs2_new_inode(dir_i, mode, ri); 4561da177e4SLinus Torvalds 4571da177e4SLinus Torvalds if (IS_ERR(inode)) { 4581da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 4591da177e4SLinus Torvalds jffs2_complete_reservation(c); 4601da177e4SLinus Torvalds return PTR_ERR(inode); 4611da177e4SLinus Torvalds } 4621da177e4SLinus Torvalds 4631da177e4SLinus Torvalds inode->i_op = &jffs2_dir_inode_operations; 4641da177e4SLinus Torvalds inode->i_fop = &jffs2_dir_operations; 4651da177e4SLinus Torvalds /* Directories get nlink 2 at start */ 4661da177e4SLinus Torvalds inode->i_nlink = 2; 4671da177e4SLinus Torvalds 4681da177e4SLinus Torvalds f = JFFS2_INODE_INFO(inode); 4691da177e4SLinus Torvalds 4701da177e4SLinus Torvalds ri->data_crc = cpu_to_je32(0); 4711da177e4SLinus Torvalds ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 4721da177e4SLinus Torvalds 4731da177e4SLinus Torvalds fn = jffs2_write_dnode(c, f, ri, NULL, 0, phys_ofs, ALLOC_NORMAL); 4741da177e4SLinus Torvalds 4751da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 4761da177e4SLinus Torvalds 4771da177e4SLinus Torvalds if (IS_ERR(fn)) { 4781da177e4SLinus Torvalds /* Eeek. Wave bye bye */ 4791da177e4SLinus Torvalds up(&f->sem); 4801da177e4SLinus Torvalds jffs2_complete_reservation(c); 4811da177e4SLinus Torvalds jffs2_clear_inode(inode); 4821da177e4SLinus Torvalds return PTR_ERR(fn); 4831da177e4SLinus Torvalds } 4841da177e4SLinus Torvalds /* No data here. Only a metadata node, which will be 4851da177e4SLinus Torvalds obsoleted by the first data write 4861da177e4SLinus Torvalds */ 4871da177e4SLinus Torvalds f->metadata = fn; 4881da177e4SLinus Torvalds up(&f->sem); 4891da177e4SLinus Torvalds 4901da177e4SLinus Torvalds jffs2_complete_reservation(c); 4911da177e4SLinus Torvalds ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen, ALLOC_NORMAL); 4921da177e4SLinus Torvalds if (ret) { 4931da177e4SLinus Torvalds /* Eep. */ 4941da177e4SLinus Torvalds jffs2_clear_inode(inode); 4951da177e4SLinus Torvalds return ret; 4961da177e4SLinus Torvalds } 4971da177e4SLinus Torvalds 4981da177e4SLinus Torvalds rd = jffs2_alloc_raw_dirent(); 4991da177e4SLinus Torvalds if (!rd) { 5001da177e4SLinus Torvalds /* Argh. Now we treat it like a normal delete */ 5011da177e4SLinus Torvalds jffs2_complete_reservation(c); 5021da177e4SLinus Torvalds jffs2_clear_inode(inode); 5031da177e4SLinus Torvalds return -ENOMEM; 5041da177e4SLinus Torvalds } 5051da177e4SLinus Torvalds 5061da177e4SLinus Torvalds dir_f = JFFS2_INODE_INFO(dir_i); 5071da177e4SLinus Torvalds down(&dir_f->sem); 5081da177e4SLinus Torvalds 5091da177e4SLinus Torvalds rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 5101da177e4SLinus Torvalds rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 5111da177e4SLinus Torvalds rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 5121da177e4SLinus Torvalds rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 5131da177e4SLinus Torvalds 5141da177e4SLinus Torvalds rd->pino = cpu_to_je32(dir_i->i_ino); 5151da177e4SLinus Torvalds rd->version = cpu_to_je32(++dir_f->highest_version); 5161da177e4SLinus Torvalds rd->ino = cpu_to_je32(inode->i_ino); 5171da177e4SLinus Torvalds rd->mctime = cpu_to_je32(get_seconds()); 5181da177e4SLinus Torvalds rd->nsize = namelen; 5191da177e4SLinus Torvalds rd->type = DT_DIR; 5201da177e4SLinus Torvalds rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 5211da177e4SLinus Torvalds rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen)); 5221da177e4SLinus Torvalds 5231da177e4SLinus Torvalds fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, phys_ofs, ALLOC_NORMAL); 5241da177e4SLinus Torvalds 5251da177e4SLinus Torvalds if (IS_ERR(fd)) { 5261da177e4SLinus Torvalds /* dirent failed to write. Delete the inode normally 5271da177e4SLinus Torvalds as if it were the final unlink() */ 5281da177e4SLinus Torvalds jffs2_complete_reservation(c); 5291da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 5301da177e4SLinus Torvalds up(&dir_f->sem); 5311da177e4SLinus Torvalds jffs2_clear_inode(inode); 5321da177e4SLinus Torvalds return PTR_ERR(fd); 5331da177e4SLinus Torvalds } 5341da177e4SLinus Torvalds 5351da177e4SLinus Torvalds dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime)); 5361da177e4SLinus Torvalds dir_i->i_nlink++; 5371da177e4SLinus Torvalds 5381da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 5391da177e4SLinus Torvalds 5401da177e4SLinus Torvalds /* Link the fd into the inode's list, obsoleting an old 5411da177e4SLinus Torvalds one if necessary. */ 5421da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &dir_f->dents); 5431da177e4SLinus Torvalds 5441da177e4SLinus Torvalds up(&dir_f->sem); 5451da177e4SLinus Torvalds jffs2_complete_reservation(c); 5461da177e4SLinus Torvalds 5471da177e4SLinus Torvalds d_instantiate(dentry, inode); 5481da177e4SLinus Torvalds return 0; 5491da177e4SLinus Torvalds } 5501da177e4SLinus Torvalds 5511da177e4SLinus Torvalds static int jffs2_rmdir (struct inode *dir_i, struct dentry *dentry) 5521da177e4SLinus Torvalds { 5531da177e4SLinus Torvalds struct jffs2_inode_info *f = JFFS2_INODE_INFO(dentry->d_inode); 5541da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 5551da177e4SLinus Torvalds int ret; 5561da177e4SLinus Torvalds 5571da177e4SLinus Torvalds for (fd = f->dents ; fd; fd = fd->next) { 5581da177e4SLinus Torvalds if (fd->ino) 5591da177e4SLinus Torvalds return -ENOTEMPTY; 5601da177e4SLinus Torvalds } 5611da177e4SLinus Torvalds ret = jffs2_unlink(dir_i, dentry); 5621da177e4SLinus Torvalds if (!ret) 5631da177e4SLinus Torvalds dir_i->i_nlink--; 5641da177e4SLinus Torvalds return ret; 5651da177e4SLinus Torvalds } 5661da177e4SLinus Torvalds 5671da177e4SLinus Torvalds static int jffs2_mknod (struct inode *dir_i, struct dentry *dentry, int mode, mknod_arg_t rdev) 5681da177e4SLinus Torvalds { 5691da177e4SLinus Torvalds struct jffs2_inode_info *f, *dir_f; 5701da177e4SLinus Torvalds struct jffs2_sb_info *c; 5711da177e4SLinus Torvalds struct inode *inode; 5721da177e4SLinus Torvalds struct jffs2_raw_inode *ri; 5731da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 5741da177e4SLinus Torvalds struct jffs2_full_dnode *fn; 5751da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 5761da177e4SLinus Torvalds int namelen; 5771da177e4SLinus Torvalds jint16_t dev; 5781da177e4SLinus Torvalds int devlen = 0; 5791da177e4SLinus Torvalds uint32_t alloclen, phys_ofs; 5801da177e4SLinus Torvalds int ret; 5811da177e4SLinus Torvalds 5821da177e4SLinus Torvalds if (!old_valid_dev(rdev)) 5831da177e4SLinus Torvalds return -EINVAL; 5841da177e4SLinus Torvalds 5851da177e4SLinus Torvalds ri = jffs2_alloc_raw_inode(); 5861da177e4SLinus Torvalds if (!ri) 5871da177e4SLinus Torvalds return -ENOMEM; 5881da177e4SLinus Torvalds 5891da177e4SLinus Torvalds c = JFFS2_SB_INFO(dir_i->i_sb); 5901da177e4SLinus Torvalds 5911da177e4SLinus Torvalds if (S_ISBLK(mode) || S_ISCHR(mode)) { 5921da177e4SLinus Torvalds dev = cpu_to_je16(old_encode_dev(rdev)); 5931da177e4SLinus Torvalds devlen = sizeof(dev); 5941da177e4SLinus Torvalds } 5951da177e4SLinus Torvalds 5961da177e4SLinus Torvalds /* Try to reserve enough space for both node and dirent. 5971da177e4SLinus Torvalds * Just the node will do for now, though 5981da177e4SLinus Torvalds */ 5991da177e4SLinus Torvalds namelen = dentry->d_name.len; 6001da177e4SLinus Torvalds ret = jffs2_reserve_space(c, sizeof(*ri) + devlen, &phys_ofs, &alloclen, ALLOC_NORMAL); 6011da177e4SLinus Torvalds 6021da177e4SLinus Torvalds if (ret) { 6031da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 6041da177e4SLinus Torvalds return ret; 6051da177e4SLinus Torvalds } 6061da177e4SLinus Torvalds 6071da177e4SLinus Torvalds inode = jffs2_new_inode(dir_i, mode, ri); 6081da177e4SLinus Torvalds 6091da177e4SLinus Torvalds if (IS_ERR(inode)) { 6101da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 6111da177e4SLinus Torvalds jffs2_complete_reservation(c); 6121da177e4SLinus Torvalds return PTR_ERR(inode); 6131da177e4SLinus Torvalds } 6141da177e4SLinus Torvalds inode->i_op = &jffs2_file_inode_operations; 6151da177e4SLinus Torvalds init_special_inode(inode, inode->i_mode, rdev); 6161da177e4SLinus Torvalds 6171da177e4SLinus Torvalds f = JFFS2_INODE_INFO(inode); 6181da177e4SLinus Torvalds 6191da177e4SLinus Torvalds ri->dsize = ri->csize = cpu_to_je32(devlen); 6201da177e4SLinus Torvalds ri->totlen = cpu_to_je32(sizeof(*ri) + devlen); 6211da177e4SLinus Torvalds ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 6221da177e4SLinus Torvalds 6231da177e4SLinus Torvalds ri->compr = JFFS2_COMPR_NONE; 6241da177e4SLinus Torvalds ri->data_crc = cpu_to_je32(crc32(0, &dev, devlen)); 6251da177e4SLinus Torvalds ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 6261da177e4SLinus Torvalds 6271da177e4SLinus Torvalds fn = jffs2_write_dnode(c, f, ri, (char *)&dev, devlen, phys_ofs, ALLOC_NORMAL); 6281da177e4SLinus Torvalds 6291da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 6301da177e4SLinus Torvalds 6311da177e4SLinus Torvalds if (IS_ERR(fn)) { 6321da177e4SLinus Torvalds /* Eeek. Wave bye bye */ 6331da177e4SLinus Torvalds up(&f->sem); 6341da177e4SLinus Torvalds jffs2_complete_reservation(c); 6351da177e4SLinus Torvalds jffs2_clear_inode(inode); 6361da177e4SLinus Torvalds return PTR_ERR(fn); 6371da177e4SLinus Torvalds } 6381da177e4SLinus Torvalds /* No data here. Only a metadata node, which will be 6391da177e4SLinus Torvalds obsoleted by the first data write 6401da177e4SLinus Torvalds */ 6411da177e4SLinus Torvalds f->metadata = fn; 6421da177e4SLinus Torvalds up(&f->sem); 6431da177e4SLinus Torvalds 6441da177e4SLinus Torvalds jffs2_complete_reservation(c); 6451da177e4SLinus Torvalds ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen, ALLOC_NORMAL); 6461da177e4SLinus Torvalds if (ret) { 6471da177e4SLinus Torvalds /* Eep. */ 6481da177e4SLinus Torvalds jffs2_clear_inode(inode); 6491da177e4SLinus Torvalds return ret; 6501da177e4SLinus Torvalds } 6511da177e4SLinus Torvalds 6521da177e4SLinus Torvalds rd = jffs2_alloc_raw_dirent(); 6531da177e4SLinus Torvalds if (!rd) { 6541da177e4SLinus Torvalds /* Argh. Now we treat it like a normal delete */ 6551da177e4SLinus Torvalds jffs2_complete_reservation(c); 6561da177e4SLinus Torvalds jffs2_clear_inode(inode); 6571da177e4SLinus Torvalds return -ENOMEM; 6581da177e4SLinus Torvalds } 6591da177e4SLinus Torvalds 6601da177e4SLinus Torvalds dir_f = JFFS2_INODE_INFO(dir_i); 6611da177e4SLinus Torvalds down(&dir_f->sem); 6621da177e4SLinus Torvalds 6631da177e4SLinus Torvalds rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 6641da177e4SLinus Torvalds rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 6651da177e4SLinus Torvalds rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 6661da177e4SLinus Torvalds rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 6671da177e4SLinus Torvalds 6681da177e4SLinus Torvalds rd->pino = cpu_to_je32(dir_i->i_ino); 6691da177e4SLinus Torvalds rd->version = cpu_to_je32(++dir_f->highest_version); 6701da177e4SLinus Torvalds rd->ino = cpu_to_je32(inode->i_ino); 6711da177e4SLinus Torvalds rd->mctime = cpu_to_je32(get_seconds()); 6721da177e4SLinus Torvalds rd->nsize = namelen; 6731da177e4SLinus Torvalds 6741da177e4SLinus Torvalds /* XXX: This is ugly. */ 6751da177e4SLinus Torvalds rd->type = (mode & S_IFMT) >> 12; 6761da177e4SLinus Torvalds 6771da177e4SLinus Torvalds rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 6781da177e4SLinus Torvalds rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen)); 6791da177e4SLinus Torvalds 6801da177e4SLinus Torvalds fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, phys_ofs, ALLOC_NORMAL); 6811da177e4SLinus Torvalds 6821da177e4SLinus Torvalds if (IS_ERR(fd)) { 6831da177e4SLinus Torvalds /* dirent failed to write. Delete the inode normally 6841da177e4SLinus Torvalds as if it were the final unlink() */ 6851da177e4SLinus Torvalds jffs2_complete_reservation(c); 6861da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 6871da177e4SLinus Torvalds up(&dir_f->sem); 6881da177e4SLinus Torvalds jffs2_clear_inode(inode); 6891da177e4SLinus Torvalds return PTR_ERR(fd); 6901da177e4SLinus Torvalds } 6911da177e4SLinus Torvalds 6921da177e4SLinus Torvalds dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime)); 6931da177e4SLinus Torvalds 6941da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 6951da177e4SLinus Torvalds 6961da177e4SLinus Torvalds /* Link the fd into the inode's list, obsoleting an old 6971da177e4SLinus Torvalds one if necessary. */ 6981da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &dir_f->dents); 6991da177e4SLinus Torvalds 7001da177e4SLinus Torvalds up(&dir_f->sem); 7011da177e4SLinus Torvalds jffs2_complete_reservation(c); 7021da177e4SLinus Torvalds 7031da177e4SLinus Torvalds d_instantiate(dentry, inode); 7041da177e4SLinus Torvalds 7051da177e4SLinus Torvalds return 0; 7061da177e4SLinus Torvalds } 7071da177e4SLinus Torvalds 7081da177e4SLinus Torvalds static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry, 7091da177e4SLinus Torvalds struct inode *new_dir_i, struct dentry *new_dentry) 7101da177e4SLinus Torvalds { 7111da177e4SLinus Torvalds int ret; 7121da177e4SLinus Torvalds struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dir_i->i_sb); 7131da177e4SLinus Torvalds struct jffs2_inode_info *victim_f = NULL; 7141da177e4SLinus Torvalds uint8_t type; 7151da177e4SLinus Torvalds 7161da177e4SLinus Torvalds /* The VFS will check for us and prevent trying to rename a 7171da177e4SLinus Torvalds * file over a directory and vice versa, but if it's a directory, 7181da177e4SLinus Torvalds * the VFS can't check whether the victim is empty. The filesystem 7191da177e4SLinus Torvalds * needs to do that for itself. 7201da177e4SLinus Torvalds */ 7211da177e4SLinus Torvalds if (new_dentry->d_inode) { 7221da177e4SLinus Torvalds victim_f = JFFS2_INODE_INFO(new_dentry->d_inode); 7231da177e4SLinus Torvalds if (S_ISDIR(new_dentry->d_inode->i_mode)) { 7241da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 7251da177e4SLinus Torvalds 7261da177e4SLinus Torvalds down(&victim_f->sem); 7271da177e4SLinus Torvalds for (fd = victim_f->dents; fd; fd = fd->next) { 7281da177e4SLinus Torvalds if (fd->ino) { 7291da177e4SLinus Torvalds up(&victim_f->sem); 7301da177e4SLinus Torvalds return -ENOTEMPTY; 7311da177e4SLinus Torvalds } 7321da177e4SLinus Torvalds } 7331da177e4SLinus Torvalds up(&victim_f->sem); 7341da177e4SLinus Torvalds } 7351da177e4SLinus Torvalds } 7361da177e4SLinus Torvalds 7371da177e4SLinus Torvalds /* XXX: We probably ought to alloc enough space for 7381da177e4SLinus Torvalds both nodes at the same time. Writing the new link, 7391da177e4SLinus Torvalds then getting -ENOSPC, is quite bad :) 7401da177e4SLinus Torvalds */ 7411da177e4SLinus Torvalds 7421da177e4SLinus Torvalds /* Make a hard link */ 7431da177e4SLinus Torvalds 7441da177e4SLinus Torvalds /* XXX: This is ugly */ 7451da177e4SLinus Torvalds type = (old_dentry->d_inode->i_mode & S_IFMT) >> 12; 7461da177e4SLinus Torvalds if (!type) type = DT_REG; 7471da177e4SLinus Torvalds 7481da177e4SLinus Torvalds ret = jffs2_do_link(c, JFFS2_INODE_INFO(new_dir_i), 7491da177e4SLinus Torvalds old_dentry->d_inode->i_ino, type, 7501da177e4SLinus Torvalds new_dentry->d_name.name, new_dentry->d_name.len); 7511da177e4SLinus Torvalds 7521da177e4SLinus Torvalds if (ret) 7531da177e4SLinus Torvalds return ret; 7541da177e4SLinus Torvalds 7551da177e4SLinus Torvalds if (victim_f) { 7561da177e4SLinus Torvalds /* There was a victim. Kill it off nicely */ 7571da177e4SLinus Torvalds new_dentry->d_inode->i_nlink--; 7581da177e4SLinus Torvalds /* Don't oops if the victim was a dirent pointing to an 7591da177e4SLinus Torvalds inode which didn't exist. */ 7601da177e4SLinus Torvalds if (victim_f->inocache) { 7611da177e4SLinus Torvalds down(&victim_f->sem); 7621da177e4SLinus Torvalds victim_f->inocache->nlink--; 7631da177e4SLinus Torvalds up(&victim_f->sem); 7641da177e4SLinus Torvalds } 7651da177e4SLinus Torvalds } 7661da177e4SLinus Torvalds 7671da177e4SLinus Torvalds /* If it was a directory we moved, and there was no victim, 7681da177e4SLinus Torvalds increase i_nlink on its new parent */ 7691da177e4SLinus Torvalds if (S_ISDIR(old_dentry->d_inode->i_mode) && !victim_f) 7701da177e4SLinus Torvalds new_dir_i->i_nlink++; 7711da177e4SLinus Torvalds 7721da177e4SLinus Torvalds /* Unlink the original */ 7731da177e4SLinus Torvalds ret = jffs2_do_unlink(c, JFFS2_INODE_INFO(old_dir_i), 7741da177e4SLinus Torvalds old_dentry->d_name.name, old_dentry->d_name.len, NULL); 7751da177e4SLinus Torvalds 7761da177e4SLinus Torvalds /* We don't touch inode->i_nlink */ 7771da177e4SLinus Torvalds 7781da177e4SLinus Torvalds if (ret) { 7791da177e4SLinus Torvalds /* Oh shit. We really ought to make a single node which can do both atomically */ 7801da177e4SLinus Torvalds struct jffs2_inode_info *f = JFFS2_INODE_INFO(old_dentry->d_inode); 7811da177e4SLinus Torvalds down(&f->sem); 7821da177e4SLinus Torvalds old_dentry->d_inode->i_nlink++; 7831da177e4SLinus Torvalds if (f->inocache) 7841da177e4SLinus Torvalds f->inocache->nlink++; 7851da177e4SLinus Torvalds up(&f->sem); 7861da177e4SLinus Torvalds 7871da177e4SLinus Torvalds printk(KERN_NOTICE "jffs2_rename(): Link succeeded, unlink failed (err %d). You now have a hard link\n", ret); 7881da177e4SLinus Torvalds /* Might as well let the VFS know */ 7891da177e4SLinus Torvalds d_instantiate(new_dentry, old_dentry->d_inode); 7901da177e4SLinus Torvalds atomic_inc(&old_dentry->d_inode->i_count); 7911da177e4SLinus Torvalds return ret; 7921da177e4SLinus Torvalds } 7931da177e4SLinus Torvalds 7941da177e4SLinus Torvalds if (S_ISDIR(old_dentry->d_inode->i_mode)) 7951da177e4SLinus Torvalds old_dir_i->i_nlink--; 7961da177e4SLinus Torvalds 7971da177e4SLinus Torvalds return 0; 7981da177e4SLinus Torvalds } 7991da177e4SLinus Torvalds 800