11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * JFFS2 -- Journalling Flash File System, Version 2. 31da177e4SLinus Torvalds * 4c00c310eSDavid Woodhouse * Copyright © 2001-2007 Red Hat, Inc. 56088c058SDavid Woodhouse * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org> 61da177e4SLinus Torvalds * 71da177e4SLinus Torvalds * Created by David Woodhouse <dwmw2@infradead.org> 81da177e4SLinus Torvalds * 91da177e4SLinus Torvalds * For licensing information, see the file 'LICENCE' in this directory. 101da177e4SLinus Torvalds * 111da177e4SLinus Torvalds */ 121da177e4SLinus Torvalds 135a528957SJoe Perches #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 145a528957SJoe Perches 151da177e4SLinus Torvalds #include <linux/kernel.h> 161da177e4SLinus Torvalds #include <linux/slab.h> 171da177e4SLinus Torvalds #include <linux/fs.h> 181da177e4SLinus Torvalds #include <linux/crc32.h> 191da177e4SLinus Torvalds #include <linux/jffs2.h> 20cbb9a561SDavid Woodhouse #include "jffs2_fs_i.h" 21cbb9a561SDavid Woodhouse #include "jffs2_fs_sb.h" 221da177e4SLinus Torvalds #include <linux/time.h> 231da177e4SLinus Torvalds #include "nodelist.h" 241da177e4SLinus Torvalds 250312fa7cSAl Viro static int jffs2_readdir (struct file *, struct dir_context *); 261da177e4SLinus Torvalds 274acdaf27SAl Viro static int jffs2_create (struct inode *,struct dentry *,umode_t, 28ebfc3b49SAl Viro bool); 291da177e4SLinus Torvalds static struct dentry *jffs2_lookup (struct inode *,struct dentry *, 3000cd8dd3SAl Viro unsigned int); 311da177e4SLinus Torvalds static int jffs2_link (struct dentry *,struct inode *,struct dentry *); 321da177e4SLinus Torvalds static int jffs2_unlink (struct inode *,struct dentry *); 331da177e4SLinus Torvalds static int jffs2_symlink (struct inode *,struct dentry *,const char *); 3418bb1db3SAl Viro static int jffs2_mkdir (struct inode *,struct dentry *,umode_t); 351da177e4SLinus Torvalds static int jffs2_rmdir (struct inode *,struct dentry *); 361a67aafbSAl Viro static int jffs2_mknod (struct inode *,struct dentry *,umode_t,dev_t); 371da177e4SLinus Torvalds static int jffs2_rename (struct inode *, struct dentry *, 381da177e4SLinus Torvalds struct inode *, struct dentry *); 391da177e4SLinus Torvalds 404b6f5d20SArjan van de Ven const struct file_operations jffs2_dir_operations = 411da177e4SLinus Torvalds { 421da177e4SLinus Torvalds .read = generic_read_dir, 43c51da20cSAl Viro .iterate_shared=jffs2_readdir, 440533400bSStoyan Gaydarov .unlocked_ioctl=jffs2_ioctl, 453222a3e5SChristoph Hellwig .fsync = jffs2_fsync, 463222a3e5SChristoph Hellwig .llseek = generic_file_llseek, 471da177e4SLinus Torvalds }; 481da177e4SLinus Torvalds 491da177e4SLinus Torvalds 5092e1d5beSArjan van de Ven const struct inode_operations jffs2_dir_inode_operations = 511da177e4SLinus Torvalds { 52265489f0SDavid Woodhouse .create = jffs2_create, 53265489f0SDavid Woodhouse .lookup = jffs2_lookup, 541da177e4SLinus Torvalds .link = jffs2_link, 551da177e4SLinus Torvalds .unlink = jffs2_unlink, 561da177e4SLinus Torvalds .symlink = jffs2_symlink, 571da177e4SLinus Torvalds .mkdir = jffs2_mkdir, 581da177e4SLinus Torvalds .rmdir = jffs2_rmdir, 591da177e4SLinus Torvalds .mknod = jffs2_mknod, 601da177e4SLinus Torvalds .rename = jffs2_rename, 614e34e719SChristoph Hellwig .get_acl = jffs2_get_acl, 62f2963d45SChristoph Hellwig .set_acl = jffs2_set_acl, 631da177e4SLinus Torvalds .setattr = jffs2_setattr, 64aa98d7cfSKaiGai Kohei .setxattr = jffs2_setxattr, 65aa98d7cfSKaiGai Kohei .getxattr = jffs2_getxattr, 66aa98d7cfSKaiGai Kohei .listxattr = jffs2_listxattr, 67aa98d7cfSKaiGai Kohei .removexattr = jffs2_removexattr 681da177e4SLinus Torvalds }; 691da177e4SLinus Torvalds 701da177e4SLinus Torvalds /***********************************************************************/ 711da177e4SLinus Torvalds 721da177e4SLinus Torvalds 731da177e4SLinus Torvalds /* We keep the dirent list sorted in increasing order of name hash, 741da177e4SLinus Torvalds and we use the same hash function as the dentries. Makes this 751da177e4SLinus Torvalds nice and simple 761da177e4SLinus Torvalds */ 771da177e4SLinus Torvalds static struct dentry *jffs2_lookup(struct inode *dir_i, struct dentry *target, 7800cd8dd3SAl Viro unsigned int flags) 791da177e4SLinus Torvalds { 801da177e4SLinus Torvalds struct jffs2_inode_info *dir_f; 811da177e4SLinus Torvalds struct jffs2_full_dirent *fd = NULL, *fd_list; 821da177e4SLinus Torvalds uint32_t ino = 0; 831da177e4SLinus Torvalds struct inode *inode = NULL; 848387ff25SLinus Torvalds unsigned int nhash; 851da177e4SLinus Torvalds 869c261b33SJoe Perches jffs2_dbg(1, "jffs2_lookup()\n"); 871da177e4SLinus Torvalds 88373d5e71SRichard Purdie if (target->d_name.len > JFFS2_MAX_NAME_LEN) 89373d5e71SRichard Purdie return ERR_PTR(-ENAMETOOLONG); 90373d5e71SRichard Purdie 911da177e4SLinus Torvalds dir_f = JFFS2_INODE_INFO(dir_i); 921da177e4SLinus Torvalds 938387ff25SLinus Torvalds /* The 'nhash' on the fd_list is not the same as the dentry hash */ 948387ff25SLinus Torvalds nhash = full_name_hash(NULL, target->d_name.name, target->d_name.len); 958387ff25SLinus Torvalds 96ced22070SDavid Woodhouse mutex_lock(&dir_f->sem); 971da177e4SLinus Torvalds 981da177e4SLinus Torvalds /* NB: The 2.2 backport will need to explicitly check for '.' and '..' here */ 998387ff25SLinus Torvalds for (fd_list = dir_f->dents; fd_list && fd_list->nhash <= nhash; fd_list = fd_list->next) { 1008387ff25SLinus Torvalds if (fd_list->nhash == nhash && 1011da177e4SLinus Torvalds (!fd || fd_list->version > fd->version) && 1021da177e4SLinus Torvalds strlen(fd_list->name) == target->d_name.len && 1031da177e4SLinus Torvalds !strncmp(fd_list->name, target->d_name.name, target->d_name.len)) { 1041da177e4SLinus Torvalds fd = fd_list; 1051da177e4SLinus Torvalds } 1061da177e4SLinus Torvalds } 1071da177e4SLinus Torvalds if (fd) 1081da177e4SLinus Torvalds ino = fd->ino; 109ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 1101da177e4SLinus Torvalds if (ino) { 1115451f79fSDavid Howells inode = jffs2_iget(dir_i->i_sb, ino); 112a9049376SAl Viro if (IS_ERR(inode)) 113da320f05SJoe Perches pr_warn("iget() failed for ino #%u\n", ino); 1141da177e4SLinus Torvalds } 1151da177e4SLinus Torvalds 1168966c5e0SDavid Woodhouse return d_splice_alias(inode, target); 1171da177e4SLinus Torvalds } 1181da177e4SLinus Torvalds 1191da177e4SLinus Torvalds /***********************************************************************/ 1201da177e4SLinus Torvalds 1211da177e4SLinus Torvalds 1220312fa7cSAl Viro static int jffs2_readdir(struct file *file, struct dir_context *ctx) 1231da177e4SLinus Torvalds { 1240312fa7cSAl Viro struct inode *inode = file_inode(file); 1250312fa7cSAl Viro struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode); 1261da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 1270312fa7cSAl Viro unsigned long curofs = 1; 1281da177e4SLinus Torvalds 1290312fa7cSAl Viro jffs2_dbg(1, "jffs2_readdir() for dir_i #%lu\n", inode->i_ino); 1301da177e4SLinus Torvalds 1310312fa7cSAl Viro if (!dir_emit_dots(file, ctx)) 1320312fa7cSAl Viro return 0; 1331da177e4SLinus Torvalds 134ced22070SDavid Woodhouse mutex_lock(&f->sem); 1351da177e4SLinus Torvalds for (fd = f->dents; fd; fd = fd->next) { 1361da177e4SLinus Torvalds curofs++; 1370312fa7cSAl Viro /* First loop: curofs = 2; pos = 2 */ 1380312fa7cSAl Viro if (curofs < ctx->pos) { 1399c261b33SJoe Perches jffs2_dbg(2, "Skipping dirent: \"%s\", ino #%u, type %d, because curofs %ld < offset %ld\n", 1400312fa7cSAl Viro fd->name, fd->ino, fd->type, curofs, (unsigned long)ctx->pos); 1411da177e4SLinus Torvalds continue; 1421da177e4SLinus Torvalds } 1431da177e4SLinus Torvalds if (!fd->ino) { 1449c261b33SJoe Perches jffs2_dbg(2, "Skipping deletion dirent \"%s\"\n", 1459c261b33SJoe Perches fd->name); 1460312fa7cSAl Viro ctx->pos++; 1471da177e4SLinus Torvalds continue; 1481da177e4SLinus Torvalds } 1499c261b33SJoe Perches jffs2_dbg(2, "Dirent %ld: \"%s\", ino #%u, type %d\n", 1500312fa7cSAl Viro (unsigned long)ctx->pos, fd->name, fd->ino, fd->type); 1510312fa7cSAl Viro if (!dir_emit(ctx, fd->name, strlen(fd->name), fd->ino, fd->type)) 1521da177e4SLinus Torvalds break; 1530312fa7cSAl Viro ctx->pos++; 1541da177e4SLinus Torvalds } 155ced22070SDavid Woodhouse mutex_unlock(&f->sem); 1561da177e4SLinus Torvalds return 0; 1571da177e4SLinus Torvalds } 1581da177e4SLinus Torvalds 1591da177e4SLinus Torvalds /***********************************************************************/ 1601da177e4SLinus Torvalds 1611da177e4SLinus Torvalds 1624acdaf27SAl Viro static int jffs2_create(struct inode *dir_i, struct dentry *dentry, 163ebfc3b49SAl Viro umode_t mode, bool excl) 1641da177e4SLinus Torvalds { 1651da177e4SLinus Torvalds struct jffs2_raw_inode *ri; 1661da177e4SLinus Torvalds struct jffs2_inode_info *f, *dir_f; 1671da177e4SLinus Torvalds struct jffs2_sb_info *c; 1681da177e4SLinus Torvalds struct inode *inode; 1691da177e4SLinus Torvalds int ret; 1701da177e4SLinus Torvalds 1711da177e4SLinus Torvalds ri = jffs2_alloc_raw_inode(); 1721da177e4SLinus Torvalds if (!ri) 1731da177e4SLinus Torvalds return -ENOMEM; 1741da177e4SLinus Torvalds 1751da177e4SLinus Torvalds c = JFFS2_SB_INFO(dir_i->i_sb); 1761da177e4SLinus Torvalds 1779c261b33SJoe Perches jffs2_dbg(1, "%s()\n", __func__); 1781da177e4SLinus Torvalds 179cfc8dc6fSKaiGai Kohei inode = jffs2_new_inode(dir_i, mode, ri); 1801da177e4SLinus Torvalds 1811da177e4SLinus Torvalds if (IS_ERR(inode)) { 1829c261b33SJoe Perches jffs2_dbg(1, "jffs2_new_inode() failed\n"); 1831da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 1841da177e4SLinus Torvalds return PTR_ERR(inode); 1851da177e4SLinus Torvalds } 1861da177e4SLinus Torvalds 1871da177e4SLinus Torvalds inode->i_op = &jffs2_file_inode_operations; 1881da177e4SLinus Torvalds inode->i_fop = &jffs2_file_operations; 1891da177e4SLinus Torvalds inode->i_mapping->a_ops = &jffs2_file_address_operations; 1901da177e4SLinus Torvalds inode->i_mapping->nrpages = 0; 1911da177e4SLinus Torvalds 1921da177e4SLinus Torvalds f = JFFS2_INODE_INFO(inode); 1931da177e4SLinus Torvalds dir_f = JFFS2_INODE_INFO(dir_i); 1941da177e4SLinus Torvalds 195590fe34cSDavid Woodhouse /* jffs2_do_create() will want to lock it, _after_ reserving 196590fe34cSDavid Woodhouse space and taking c-alloc_sem. If we keep it locked here, 197590fe34cSDavid Woodhouse lockdep gets unhappy (although it's a false positive; 198590fe34cSDavid Woodhouse nothing else will be looking at this inode yet so there's 199590fe34cSDavid Woodhouse no chance of AB-BA deadlock involving its f->sem). */ 200590fe34cSDavid Woodhouse mutex_unlock(&f->sem); 201590fe34cSDavid Woodhouse 2022a7dba39SEric Paris ret = jffs2_do_create(c, dir_f, f, ri, &dentry->d_name); 203aa98d7cfSKaiGai Kohei if (ret) 204aa98d7cfSKaiGai Kohei goto fail; 2051da177e4SLinus Torvalds 2061da177e4SLinus Torvalds dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(ri->ctime)); 2071da177e4SLinus Torvalds 2081da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 2091da177e4SLinus Torvalds 2109c261b33SJoe Perches jffs2_dbg(1, "%s(): Created ino #%lu with mode %o, nlink %d(%d). nrpages %ld\n", 2119c261b33SJoe Perches __func__, inode->i_ino, inode->i_mode, inode->i_nlink, 2129c261b33SJoe Perches f->inocache->pino_nlink, inode->i_mapping->nrpages); 213e72e6497SDavid Woodhouse 214e72e6497SDavid Woodhouse unlock_new_inode(inode); 2158fc37ec5SAl Viro d_instantiate(dentry, inode); 2161da177e4SLinus Torvalds return 0; 217aa98d7cfSKaiGai Kohei 218aa98d7cfSKaiGai Kohei fail: 21941cce647SAl Viro iget_failed(inode); 220aa98d7cfSKaiGai Kohei jffs2_free_raw_inode(ri); 221aa98d7cfSKaiGai Kohei return ret; 2221da177e4SLinus Torvalds } 2231da177e4SLinus Torvalds 2241da177e4SLinus Torvalds /***********************************************************************/ 2251da177e4SLinus Torvalds 2261da177e4SLinus Torvalds 2271da177e4SLinus Torvalds static int jffs2_unlink(struct inode *dir_i, struct dentry *dentry) 2281da177e4SLinus Torvalds { 2291da177e4SLinus Torvalds struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb); 2301da177e4SLinus Torvalds struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); 2312b0143b5SDavid Howells struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(d_inode(dentry)); 2321da177e4SLinus Torvalds int ret; 2333a69e0cdSArtem B. Bityutskiy uint32_t now = get_seconds(); 2341da177e4SLinus Torvalds 2351da177e4SLinus Torvalds ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name, 2363a69e0cdSArtem B. Bityutskiy dentry->d_name.len, dead_f, now); 2371da177e4SLinus Torvalds if (dead_f->inocache) 2382b0143b5SDavid Howells set_nlink(d_inode(dentry), dead_f->inocache->pino_nlink); 2393a69e0cdSArtem B. Bityutskiy if (!ret) 2403a69e0cdSArtem B. Bityutskiy dir_i->i_mtime = dir_i->i_ctime = ITIME(now); 2411da177e4SLinus Torvalds return ret; 2421da177e4SLinus Torvalds } 2431da177e4SLinus Torvalds /***********************************************************************/ 2441da177e4SLinus Torvalds 2451da177e4SLinus Torvalds 2461da177e4SLinus Torvalds static int jffs2_link (struct dentry *old_dentry, struct inode *dir_i, struct dentry *dentry) 2471da177e4SLinus Torvalds { 248fc64005cSAl Viro struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dentry->d_sb); 2492b0143b5SDavid Howells struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry)); 2501da177e4SLinus Torvalds struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); 2511da177e4SLinus Torvalds int ret; 2521da177e4SLinus Torvalds uint8_t type; 2533a69e0cdSArtem B. Bityutskiy uint32_t now; 2541da177e4SLinus Torvalds 2551da177e4SLinus Torvalds /* Don't let people make hard links to bad inodes. */ 2561da177e4SLinus Torvalds if (!f->inocache) 2571da177e4SLinus Torvalds return -EIO; 2581da177e4SLinus Torvalds 259e36cb0b8SDavid Howells if (d_is_dir(old_dentry)) 2601da177e4SLinus Torvalds return -EPERM; 2611da177e4SLinus Torvalds 2621da177e4SLinus Torvalds /* XXX: This is ugly */ 2632b0143b5SDavid Howells type = (d_inode(old_dentry)->i_mode & S_IFMT) >> 12; 2641da177e4SLinus Torvalds if (!type) type = DT_REG; 2651da177e4SLinus Torvalds 2663a69e0cdSArtem B. Bityutskiy now = get_seconds(); 2673a69e0cdSArtem B. Bityutskiy ret = jffs2_do_link(c, dir_f, f->inocache->ino, type, dentry->d_name.name, dentry->d_name.len, now); 2681da177e4SLinus Torvalds 2691da177e4SLinus Torvalds if (!ret) { 270ced22070SDavid Woodhouse mutex_lock(&f->sem); 2712b0143b5SDavid Howells set_nlink(d_inode(old_dentry), ++f->inocache->pino_nlink); 272ced22070SDavid Woodhouse mutex_unlock(&f->sem); 2732b0143b5SDavid Howells d_instantiate(dentry, d_inode(old_dentry)); 2743a69e0cdSArtem B. Bityutskiy dir_i->i_mtime = dir_i->i_ctime = ITIME(now); 2752b0143b5SDavid Howells ihold(d_inode(old_dentry)); 2761da177e4SLinus Torvalds } 2771da177e4SLinus Torvalds return ret; 2781da177e4SLinus Torvalds } 2791da177e4SLinus Torvalds 2801da177e4SLinus Torvalds /***********************************************************************/ 2811da177e4SLinus Torvalds 2821da177e4SLinus Torvalds static int jffs2_symlink (struct inode *dir_i, struct dentry *dentry, const char *target) 2831da177e4SLinus Torvalds { 2841da177e4SLinus Torvalds struct jffs2_inode_info *f, *dir_f; 2851da177e4SLinus Torvalds struct jffs2_sb_info *c; 2861da177e4SLinus Torvalds struct inode *inode; 2871da177e4SLinus Torvalds struct jffs2_raw_inode *ri; 2881da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 2891da177e4SLinus Torvalds struct jffs2_full_dnode *fn; 2901da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 2911da177e4SLinus Torvalds int namelen; 2929fe4854cSDavid Woodhouse uint32_t alloclen; 29332f1a95dSArtem B. Bityuckiy int ret, targetlen = strlen(target); 2941da177e4SLinus Torvalds 2951da177e4SLinus Torvalds /* FIXME: If you care. We'd need to use frags for the target 2961da177e4SLinus Torvalds if it grows much more than this */ 29732f1a95dSArtem B. Bityuckiy if (targetlen > 254) 298bde86fecSAdrian Hunter return -ENAMETOOLONG; 2991da177e4SLinus Torvalds 3001da177e4SLinus Torvalds ri = jffs2_alloc_raw_inode(); 3011da177e4SLinus Torvalds 3021da177e4SLinus Torvalds if (!ri) 3031da177e4SLinus Torvalds return -ENOMEM; 3041da177e4SLinus Torvalds 3051da177e4SLinus Torvalds c = JFFS2_SB_INFO(dir_i->i_sb); 3061da177e4SLinus Torvalds 3071da177e4SLinus Torvalds /* Try to reserve enough space for both node and dirent. 3081da177e4SLinus Torvalds * Just the node will do for now, though 3091da177e4SLinus Torvalds */ 3101da177e4SLinus Torvalds namelen = dentry->d_name.len; 3119fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*ri) + targetlen, &alloclen, 312e631ddbaSFerenc Havasi ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE); 3131da177e4SLinus Torvalds 3141da177e4SLinus Torvalds if (ret) { 3151da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 3161da177e4SLinus Torvalds return ret; 3171da177e4SLinus Torvalds } 3181da177e4SLinus Torvalds 319cfc8dc6fSKaiGai Kohei inode = jffs2_new_inode(dir_i, S_IFLNK | S_IRWXUGO, ri); 3201da177e4SLinus Torvalds 3211da177e4SLinus Torvalds if (IS_ERR(inode)) { 3221da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 3231da177e4SLinus Torvalds jffs2_complete_reservation(c); 3241da177e4SLinus Torvalds return PTR_ERR(inode); 3251da177e4SLinus Torvalds } 3261da177e4SLinus Torvalds 3271da177e4SLinus Torvalds inode->i_op = &jffs2_symlink_inode_operations; 3281da177e4SLinus Torvalds 3291da177e4SLinus Torvalds f = JFFS2_INODE_INFO(inode); 3301da177e4SLinus Torvalds 33132f1a95dSArtem B. Bityuckiy inode->i_size = targetlen; 3321da177e4SLinus Torvalds ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size); 3331da177e4SLinus Torvalds ri->totlen = cpu_to_je32(sizeof(*ri) + inode->i_size); 3341da177e4SLinus Torvalds ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 3351da177e4SLinus Torvalds 3361da177e4SLinus Torvalds ri->compr = JFFS2_COMPR_NONE; 33732f1a95dSArtem B. Bityuckiy ri->data_crc = cpu_to_je32(crc32(0, target, targetlen)); 3381da177e4SLinus Torvalds ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 3391da177e4SLinus Torvalds 3409fe4854cSDavid Woodhouse fn = jffs2_write_dnode(c, f, ri, target, targetlen, ALLOC_NORMAL); 3411da177e4SLinus Torvalds 3421da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 3431da177e4SLinus Torvalds 3441da177e4SLinus Torvalds if (IS_ERR(fn)) { 3451da177e4SLinus Torvalds /* Eeek. Wave bye bye */ 346ced22070SDavid Woodhouse mutex_unlock(&f->sem); 3471da177e4SLinus Torvalds jffs2_complete_reservation(c); 348f324e4cbSDavid Woodhouse ret = PTR_ERR(fn); 349f324e4cbSDavid Woodhouse goto fail; 3501da177e4SLinus Torvalds } 35132f1a95dSArtem B. Bityuckiy 3522b79adccSArtem B. Bityutskiy /* We use f->target field to store the target path. */ 35304aadf36SJulia Lawall f->target = kmemdup(target, targetlen + 1, GFP_KERNEL); 3542b79adccSArtem B. Bityutskiy if (!f->target) { 355da320f05SJoe Perches pr_warn("Can't allocate %d bytes of memory\n", targetlen + 1); 356ced22070SDavid Woodhouse mutex_unlock(&f->sem); 35732f1a95dSArtem B. Bityuckiy jffs2_complete_reservation(c); 358f324e4cbSDavid Woodhouse ret = -ENOMEM; 359f324e4cbSDavid Woodhouse goto fail; 36032f1a95dSArtem B. Bityuckiy } 361a8db149fSAl Viro inode->i_link = f->target; 36232f1a95dSArtem B. Bityuckiy 3639c261b33SJoe Perches jffs2_dbg(1, "%s(): symlink's target '%s' cached\n", 3649c261b33SJoe Perches __func__, (char *)f->target); 36532f1a95dSArtem B. Bityuckiy 3661da177e4SLinus Torvalds /* No data here. Only a metadata node, which will be 3671da177e4SLinus Torvalds obsoleted by the first data write 3681da177e4SLinus Torvalds */ 3691da177e4SLinus Torvalds f->metadata = fn; 370ced22070SDavid Woodhouse mutex_unlock(&f->sem); 3711da177e4SLinus Torvalds 3721da177e4SLinus Torvalds jffs2_complete_reservation(c); 373aa98d7cfSKaiGai Kohei 3742a7dba39SEric Paris ret = jffs2_init_security(inode, dir_i, &dentry->d_name); 375f324e4cbSDavid Woodhouse if (ret) 376f324e4cbSDavid Woodhouse goto fail; 377f324e4cbSDavid Woodhouse 378cfc8dc6fSKaiGai Kohei ret = jffs2_init_acl_post(inode); 379f324e4cbSDavid Woodhouse if (ret) 380f324e4cbSDavid Woodhouse goto fail; 381aa98d7cfSKaiGai Kohei 3829fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 383e631ddbaSFerenc Havasi ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 384f324e4cbSDavid Woodhouse if (ret) 385f324e4cbSDavid Woodhouse goto fail; 3861da177e4SLinus Torvalds 3871da177e4SLinus Torvalds rd = jffs2_alloc_raw_dirent(); 3881da177e4SLinus Torvalds if (!rd) { 3891da177e4SLinus Torvalds /* Argh. Now we treat it like a normal delete */ 3901da177e4SLinus Torvalds jffs2_complete_reservation(c); 391f324e4cbSDavid Woodhouse ret = -ENOMEM; 392f324e4cbSDavid Woodhouse goto fail; 3931da177e4SLinus Torvalds } 3941da177e4SLinus Torvalds 3951da177e4SLinus Torvalds dir_f = JFFS2_INODE_INFO(dir_i); 396ced22070SDavid Woodhouse mutex_lock(&dir_f->sem); 3971da177e4SLinus Torvalds 3981da177e4SLinus Torvalds rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 3991da177e4SLinus Torvalds rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 4001da177e4SLinus Torvalds rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 4011da177e4SLinus Torvalds rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 4021da177e4SLinus Torvalds 4031da177e4SLinus Torvalds rd->pino = cpu_to_je32(dir_i->i_ino); 4041da177e4SLinus Torvalds rd->version = cpu_to_je32(++dir_f->highest_version); 4051da177e4SLinus Torvalds rd->ino = cpu_to_je32(inode->i_ino); 4061da177e4SLinus Torvalds rd->mctime = cpu_to_je32(get_seconds()); 4071da177e4SLinus Torvalds rd->nsize = namelen; 4081da177e4SLinus Torvalds rd->type = DT_LNK; 4091da177e4SLinus Torvalds rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 4101da177e4SLinus Torvalds rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen)); 4111da177e4SLinus Torvalds 4129fe4854cSDavid Woodhouse fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL); 4131da177e4SLinus Torvalds 4141da177e4SLinus Torvalds if (IS_ERR(fd)) { 4151da177e4SLinus Torvalds /* dirent failed to write. Delete the inode normally 4161da177e4SLinus Torvalds as if it were the final unlink() */ 4171da177e4SLinus Torvalds jffs2_complete_reservation(c); 4181da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 419ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 420f324e4cbSDavid Woodhouse ret = PTR_ERR(fd); 421f324e4cbSDavid Woodhouse goto fail; 4221da177e4SLinus Torvalds } 4231da177e4SLinus Torvalds 4241da177e4SLinus Torvalds dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime)); 4251da177e4SLinus Torvalds 4261da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 4271da177e4SLinus Torvalds 4281da177e4SLinus Torvalds /* Link the fd into the inode's list, obsoleting an old 4291da177e4SLinus Torvalds one if necessary. */ 4301da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &dir_f->dents); 4311da177e4SLinus Torvalds 432ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 4331da177e4SLinus Torvalds jffs2_complete_reservation(c); 4341da177e4SLinus Torvalds 435e72e6497SDavid Woodhouse unlock_new_inode(inode); 4368fc37ec5SAl Viro d_instantiate(dentry, inode); 4371da177e4SLinus Torvalds return 0; 438f324e4cbSDavid Woodhouse 439f324e4cbSDavid Woodhouse fail: 44041cce647SAl Viro iget_failed(inode); 441f324e4cbSDavid Woodhouse return ret; 4421da177e4SLinus Torvalds } 4431da177e4SLinus Torvalds 4441da177e4SLinus Torvalds 44518bb1db3SAl Viro static int jffs2_mkdir (struct inode *dir_i, struct dentry *dentry, umode_t mode) 4461da177e4SLinus Torvalds { 4471da177e4SLinus Torvalds struct jffs2_inode_info *f, *dir_f; 4481da177e4SLinus Torvalds struct jffs2_sb_info *c; 4491da177e4SLinus Torvalds struct inode *inode; 4501da177e4SLinus Torvalds struct jffs2_raw_inode *ri; 4511da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 4521da177e4SLinus Torvalds struct jffs2_full_dnode *fn; 4531da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 4541da177e4SLinus Torvalds int namelen; 4559fe4854cSDavid Woodhouse uint32_t alloclen; 4561da177e4SLinus Torvalds int ret; 4571da177e4SLinus Torvalds 4581da177e4SLinus Torvalds mode |= S_IFDIR; 4591da177e4SLinus Torvalds 4601da177e4SLinus Torvalds ri = jffs2_alloc_raw_inode(); 4611da177e4SLinus Torvalds if (!ri) 4621da177e4SLinus Torvalds return -ENOMEM; 4631da177e4SLinus Torvalds 4641da177e4SLinus Torvalds c = JFFS2_SB_INFO(dir_i->i_sb); 4651da177e4SLinus Torvalds 4661da177e4SLinus Torvalds /* Try to reserve enough space for both node and dirent. 4671da177e4SLinus Torvalds * Just the node will do for now, though 4681da177e4SLinus Torvalds */ 4691da177e4SLinus Torvalds namelen = dentry->d_name.len; 4709fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL, 471e631ddbaSFerenc Havasi JFFS2_SUMMARY_INODE_SIZE); 4721da177e4SLinus Torvalds 4731da177e4SLinus Torvalds if (ret) { 4741da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 4751da177e4SLinus Torvalds return ret; 4761da177e4SLinus Torvalds } 4771da177e4SLinus Torvalds 478cfc8dc6fSKaiGai Kohei inode = jffs2_new_inode(dir_i, mode, ri); 4791da177e4SLinus Torvalds 4801da177e4SLinus Torvalds if (IS_ERR(inode)) { 4811da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 4821da177e4SLinus Torvalds jffs2_complete_reservation(c); 4831da177e4SLinus Torvalds return PTR_ERR(inode); 4841da177e4SLinus Torvalds } 4851da177e4SLinus Torvalds 4861da177e4SLinus Torvalds inode->i_op = &jffs2_dir_inode_operations; 4871da177e4SLinus Torvalds inode->i_fop = &jffs2_dir_operations; 4881da177e4SLinus Torvalds 4891da177e4SLinus Torvalds f = JFFS2_INODE_INFO(inode); 4901da177e4SLinus Torvalds 49127c72b04SDavid Woodhouse /* Directories get nlink 2 at start */ 492bfe86848SMiklos Szeredi set_nlink(inode, 2); 49327c72b04SDavid Woodhouse /* but ic->pino_nlink is the parent ino# */ 49427c72b04SDavid Woodhouse f->inocache->pino_nlink = dir_i->i_ino; 49527c72b04SDavid Woodhouse 4961da177e4SLinus Torvalds ri->data_crc = cpu_to_je32(0); 4971da177e4SLinus Torvalds ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 4981da177e4SLinus Torvalds 4999fe4854cSDavid Woodhouse fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL); 5001da177e4SLinus Torvalds 5011da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 5021da177e4SLinus Torvalds 5031da177e4SLinus Torvalds if (IS_ERR(fn)) { 5041da177e4SLinus Torvalds /* Eeek. Wave bye bye */ 505ced22070SDavid Woodhouse mutex_unlock(&f->sem); 5061da177e4SLinus Torvalds jffs2_complete_reservation(c); 507f324e4cbSDavid Woodhouse ret = PTR_ERR(fn); 508f324e4cbSDavid Woodhouse goto fail; 5091da177e4SLinus Torvalds } 5101da177e4SLinus Torvalds /* No data here. Only a metadata node, which will be 5111da177e4SLinus Torvalds obsoleted by the first data write 5121da177e4SLinus Torvalds */ 5131da177e4SLinus Torvalds f->metadata = fn; 514ced22070SDavid Woodhouse mutex_unlock(&f->sem); 5151da177e4SLinus Torvalds 5161da177e4SLinus Torvalds jffs2_complete_reservation(c); 517aa98d7cfSKaiGai Kohei 5182a7dba39SEric Paris ret = jffs2_init_security(inode, dir_i, &dentry->d_name); 519f324e4cbSDavid Woodhouse if (ret) 520f324e4cbSDavid Woodhouse goto fail; 521f324e4cbSDavid Woodhouse 522cfc8dc6fSKaiGai Kohei ret = jffs2_init_acl_post(inode); 523f324e4cbSDavid Woodhouse if (ret) 524f324e4cbSDavid Woodhouse goto fail; 525aa98d7cfSKaiGai Kohei 5269fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 527e631ddbaSFerenc Havasi ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 528f324e4cbSDavid Woodhouse if (ret) 529f324e4cbSDavid Woodhouse goto fail; 5301da177e4SLinus Torvalds 5311da177e4SLinus Torvalds rd = jffs2_alloc_raw_dirent(); 5321da177e4SLinus Torvalds if (!rd) { 5331da177e4SLinus Torvalds /* Argh. Now we treat it like a normal delete */ 5341da177e4SLinus Torvalds jffs2_complete_reservation(c); 535f324e4cbSDavid Woodhouse ret = -ENOMEM; 536f324e4cbSDavid Woodhouse goto fail; 5371da177e4SLinus Torvalds } 5381da177e4SLinus Torvalds 5391da177e4SLinus Torvalds dir_f = JFFS2_INODE_INFO(dir_i); 540ced22070SDavid Woodhouse mutex_lock(&dir_f->sem); 5411da177e4SLinus Torvalds 5421da177e4SLinus Torvalds rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 5431da177e4SLinus Torvalds rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 5441da177e4SLinus Torvalds rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 5451da177e4SLinus Torvalds rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 5461da177e4SLinus Torvalds 5471da177e4SLinus Torvalds rd->pino = cpu_to_je32(dir_i->i_ino); 5481da177e4SLinus Torvalds rd->version = cpu_to_je32(++dir_f->highest_version); 5491da177e4SLinus Torvalds rd->ino = cpu_to_je32(inode->i_ino); 5501da177e4SLinus Torvalds rd->mctime = cpu_to_je32(get_seconds()); 5511da177e4SLinus Torvalds rd->nsize = namelen; 5521da177e4SLinus Torvalds rd->type = DT_DIR; 5531da177e4SLinus Torvalds rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 5541da177e4SLinus Torvalds rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen)); 5551da177e4SLinus Torvalds 5569fe4854cSDavid Woodhouse fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL); 5571da177e4SLinus Torvalds 5581da177e4SLinus Torvalds if (IS_ERR(fd)) { 5591da177e4SLinus Torvalds /* dirent failed to write. Delete the inode normally 5601da177e4SLinus Torvalds as if it were the final unlink() */ 5611da177e4SLinus Torvalds jffs2_complete_reservation(c); 5621da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 563ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 564f324e4cbSDavid Woodhouse ret = PTR_ERR(fd); 565f324e4cbSDavid Woodhouse goto fail; 5661da177e4SLinus Torvalds } 5671da177e4SLinus Torvalds 5681da177e4SLinus Torvalds dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime)); 569d8c76e6fSDave Hansen inc_nlink(dir_i); 5701da177e4SLinus Torvalds 5711da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 5721da177e4SLinus Torvalds 5731da177e4SLinus Torvalds /* Link the fd into the inode's list, obsoleting an old 5741da177e4SLinus Torvalds one if necessary. */ 5751da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &dir_f->dents); 5761da177e4SLinus Torvalds 577ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 5781da177e4SLinus Torvalds jffs2_complete_reservation(c); 5791da177e4SLinus Torvalds 580e72e6497SDavid Woodhouse unlock_new_inode(inode); 5818fc37ec5SAl Viro d_instantiate(dentry, inode); 5821da177e4SLinus Torvalds return 0; 583f324e4cbSDavid Woodhouse 584f324e4cbSDavid Woodhouse fail: 58541cce647SAl Viro iget_failed(inode); 586f324e4cbSDavid Woodhouse return ret; 5871da177e4SLinus Torvalds } 5881da177e4SLinus Torvalds 5891da177e4SLinus Torvalds static int jffs2_rmdir (struct inode *dir_i, struct dentry *dentry) 5901da177e4SLinus Torvalds { 59127c72b04SDavid Woodhouse struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb); 59227c72b04SDavid Woodhouse struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); 5932b0143b5SDavid Howells struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(dentry)); 5941da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 5951da177e4SLinus Torvalds int ret; 59627c72b04SDavid Woodhouse uint32_t now = get_seconds(); 5971da177e4SLinus Torvalds 5981da177e4SLinus Torvalds for (fd = f->dents ; fd; fd = fd->next) { 5991da177e4SLinus Torvalds if (fd->ino) 6001da177e4SLinus Torvalds return -ENOTEMPTY; 6011da177e4SLinus Torvalds } 60227c72b04SDavid Woodhouse 60327c72b04SDavid Woodhouse ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name, 60427c72b04SDavid Woodhouse dentry->d_name.len, f, now); 60527c72b04SDavid Woodhouse if (!ret) { 60627c72b04SDavid Woodhouse dir_i->i_mtime = dir_i->i_ctime = ITIME(now); 6072b0143b5SDavid Howells clear_nlink(d_inode(dentry)); 6089a53c3a7SDave Hansen drop_nlink(dir_i); 60927c72b04SDavid Woodhouse } 6101da177e4SLinus Torvalds return ret; 6111da177e4SLinus Torvalds } 6121da177e4SLinus Torvalds 6131a67aafbSAl Viro static int jffs2_mknod (struct inode *dir_i, struct dentry *dentry, umode_t mode, dev_t rdev) 6141da177e4SLinus Torvalds { 6151da177e4SLinus Torvalds struct jffs2_inode_info *f, *dir_f; 6161da177e4SLinus Torvalds struct jffs2_sb_info *c; 6171da177e4SLinus Torvalds struct inode *inode; 6181da177e4SLinus Torvalds struct jffs2_raw_inode *ri; 6191da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 6201da177e4SLinus Torvalds struct jffs2_full_dnode *fn; 6211da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 6221da177e4SLinus Torvalds int namelen; 623aef9ab47SDavid Woodhouse union jffs2_device_node dev; 6241da177e4SLinus Torvalds int devlen = 0; 6259fe4854cSDavid Woodhouse uint32_t alloclen; 6261da177e4SLinus Torvalds int ret; 6271da177e4SLinus Torvalds 6281da177e4SLinus Torvalds ri = jffs2_alloc_raw_inode(); 6291da177e4SLinus Torvalds if (!ri) 6301da177e4SLinus Torvalds return -ENOMEM; 6311da177e4SLinus Torvalds 6321da177e4SLinus Torvalds c = JFFS2_SB_INFO(dir_i->i_sb); 6331da177e4SLinus Torvalds 634aef9ab47SDavid Woodhouse if (S_ISBLK(mode) || S_ISCHR(mode)) 635aef9ab47SDavid Woodhouse devlen = jffs2_encode_dev(&dev, rdev); 6361da177e4SLinus Torvalds 6371da177e4SLinus Torvalds /* Try to reserve enough space for both node and dirent. 6381da177e4SLinus Torvalds * Just the node will do for now, though 6391da177e4SLinus Torvalds */ 6401da177e4SLinus Torvalds namelen = dentry->d_name.len; 6419fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*ri) + devlen, &alloclen, 642e631ddbaSFerenc Havasi ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE); 6431da177e4SLinus Torvalds 6441da177e4SLinus Torvalds if (ret) { 6451da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 6461da177e4SLinus Torvalds return ret; 6471da177e4SLinus Torvalds } 6481da177e4SLinus Torvalds 649cfc8dc6fSKaiGai Kohei inode = jffs2_new_inode(dir_i, mode, ri); 6501da177e4SLinus Torvalds 6511da177e4SLinus Torvalds if (IS_ERR(inode)) { 6521da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 6531da177e4SLinus Torvalds jffs2_complete_reservation(c); 6541da177e4SLinus Torvalds return PTR_ERR(inode); 6551da177e4SLinus Torvalds } 6561da177e4SLinus Torvalds inode->i_op = &jffs2_file_inode_operations; 6571da177e4SLinus Torvalds init_special_inode(inode, inode->i_mode, rdev); 6581da177e4SLinus Torvalds 6591da177e4SLinus Torvalds f = JFFS2_INODE_INFO(inode); 6601da177e4SLinus Torvalds 6611da177e4SLinus Torvalds ri->dsize = ri->csize = cpu_to_je32(devlen); 6621da177e4SLinus Torvalds ri->totlen = cpu_to_je32(sizeof(*ri) + devlen); 6631da177e4SLinus Torvalds ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 6641da177e4SLinus Torvalds 6651da177e4SLinus Torvalds ri->compr = JFFS2_COMPR_NONE; 6661da177e4SLinus Torvalds ri->data_crc = cpu_to_je32(crc32(0, &dev, devlen)); 6671da177e4SLinus Torvalds ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 6681da177e4SLinus Torvalds 6699fe4854cSDavid Woodhouse fn = jffs2_write_dnode(c, f, ri, (char *)&dev, devlen, ALLOC_NORMAL); 6701da177e4SLinus Torvalds 6711da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 6721da177e4SLinus Torvalds 6731da177e4SLinus Torvalds if (IS_ERR(fn)) { 6741da177e4SLinus Torvalds /* Eeek. Wave bye bye */ 675ced22070SDavid Woodhouse mutex_unlock(&f->sem); 6761da177e4SLinus Torvalds jffs2_complete_reservation(c); 677f324e4cbSDavid Woodhouse ret = PTR_ERR(fn); 678f324e4cbSDavid Woodhouse goto fail; 6791da177e4SLinus Torvalds } 6801da177e4SLinus Torvalds /* No data here. Only a metadata node, which will be 6811da177e4SLinus Torvalds obsoleted by the first data write 6821da177e4SLinus Torvalds */ 6831da177e4SLinus Torvalds f->metadata = fn; 684ced22070SDavid Woodhouse mutex_unlock(&f->sem); 6851da177e4SLinus Torvalds 6861da177e4SLinus Torvalds jffs2_complete_reservation(c); 687aa98d7cfSKaiGai Kohei 6882a7dba39SEric Paris ret = jffs2_init_security(inode, dir_i, &dentry->d_name); 689f324e4cbSDavid Woodhouse if (ret) 690f324e4cbSDavid Woodhouse goto fail; 691f324e4cbSDavid Woodhouse 692cfc8dc6fSKaiGai Kohei ret = jffs2_init_acl_post(inode); 693f324e4cbSDavid Woodhouse if (ret) 694f324e4cbSDavid Woodhouse goto fail; 695aa98d7cfSKaiGai Kohei 6969fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 697e631ddbaSFerenc Havasi ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 698f324e4cbSDavid Woodhouse if (ret) 699f324e4cbSDavid Woodhouse goto fail; 7001da177e4SLinus Torvalds 7011da177e4SLinus Torvalds rd = jffs2_alloc_raw_dirent(); 7021da177e4SLinus Torvalds if (!rd) { 7031da177e4SLinus Torvalds /* Argh. Now we treat it like a normal delete */ 7041da177e4SLinus Torvalds jffs2_complete_reservation(c); 705f324e4cbSDavid Woodhouse ret = -ENOMEM; 706f324e4cbSDavid Woodhouse goto fail; 7071da177e4SLinus Torvalds } 7081da177e4SLinus Torvalds 7091da177e4SLinus Torvalds dir_f = JFFS2_INODE_INFO(dir_i); 710ced22070SDavid Woodhouse mutex_lock(&dir_f->sem); 7111da177e4SLinus Torvalds 7121da177e4SLinus Torvalds rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 7131da177e4SLinus Torvalds rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 7141da177e4SLinus Torvalds rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 7151da177e4SLinus Torvalds rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 7161da177e4SLinus Torvalds 7171da177e4SLinus Torvalds rd->pino = cpu_to_je32(dir_i->i_ino); 7181da177e4SLinus Torvalds rd->version = cpu_to_je32(++dir_f->highest_version); 7191da177e4SLinus Torvalds rd->ino = cpu_to_je32(inode->i_ino); 7201da177e4SLinus Torvalds rd->mctime = cpu_to_je32(get_seconds()); 7211da177e4SLinus Torvalds rd->nsize = namelen; 7221da177e4SLinus Torvalds 7231da177e4SLinus Torvalds /* XXX: This is ugly. */ 7241da177e4SLinus Torvalds rd->type = (mode & S_IFMT) >> 12; 7251da177e4SLinus Torvalds 7261da177e4SLinus Torvalds rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 7271da177e4SLinus Torvalds rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen)); 7281da177e4SLinus Torvalds 7299fe4854cSDavid Woodhouse fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL); 7301da177e4SLinus Torvalds 7311da177e4SLinus Torvalds if (IS_ERR(fd)) { 7321da177e4SLinus Torvalds /* dirent failed to write. Delete the inode normally 7331da177e4SLinus Torvalds as if it were the final unlink() */ 7341da177e4SLinus Torvalds jffs2_complete_reservation(c); 7351da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 736ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 737f324e4cbSDavid Woodhouse ret = PTR_ERR(fd); 738f324e4cbSDavid Woodhouse goto fail; 7391da177e4SLinus Torvalds } 7401da177e4SLinus Torvalds 7411da177e4SLinus Torvalds dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime)); 7421da177e4SLinus Torvalds 7431da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 7441da177e4SLinus Torvalds 7451da177e4SLinus Torvalds /* Link the fd into the inode's list, obsoleting an old 7461da177e4SLinus Torvalds one if necessary. */ 7471da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &dir_f->dents); 7481da177e4SLinus Torvalds 749ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 7501da177e4SLinus Torvalds jffs2_complete_reservation(c); 7511da177e4SLinus Torvalds 752e72e6497SDavid Woodhouse unlock_new_inode(inode); 7538fc37ec5SAl Viro d_instantiate(dentry, inode); 7541da177e4SLinus Torvalds return 0; 755f324e4cbSDavid Woodhouse 756f324e4cbSDavid Woodhouse fail: 75741cce647SAl Viro iget_failed(inode); 758f324e4cbSDavid Woodhouse return ret; 7591da177e4SLinus Torvalds } 7601da177e4SLinus Torvalds 7611da177e4SLinus Torvalds static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry, 7621da177e4SLinus Torvalds struct inode *new_dir_i, struct dentry *new_dentry) 7631da177e4SLinus Torvalds { 7641da177e4SLinus Torvalds int ret; 7651da177e4SLinus Torvalds struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dir_i->i_sb); 7661da177e4SLinus Torvalds struct jffs2_inode_info *victim_f = NULL; 7671da177e4SLinus Torvalds uint8_t type; 7683a69e0cdSArtem B. Bityutskiy uint32_t now; 7691da177e4SLinus Torvalds 7701da177e4SLinus Torvalds /* The VFS will check for us and prevent trying to rename a 7711da177e4SLinus Torvalds * file over a directory and vice versa, but if it's a directory, 7721da177e4SLinus Torvalds * the VFS can't check whether the victim is empty. The filesystem 7731da177e4SLinus Torvalds * needs to do that for itself. 7741da177e4SLinus Torvalds */ 7752b0143b5SDavid Howells if (d_really_is_positive(new_dentry)) { 7762b0143b5SDavid Howells victim_f = JFFS2_INODE_INFO(d_inode(new_dentry)); 777e36cb0b8SDavid Howells if (d_is_dir(new_dentry)) { 7781da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 7791da177e4SLinus Torvalds 780ced22070SDavid Woodhouse mutex_lock(&victim_f->sem); 7811da177e4SLinus Torvalds for (fd = victim_f->dents; fd; fd = fd->next) { 7821da177e4SLinus Torvalds if (fd->ino) { 783ced22070SDavid Woodhouse mutex_unlock(&victim_f->sem); 7841da177e4SLinus Torvalds return -ENOTEMPTY; 7851da177e4SLinus Torvalds } 7861da177e4SLinus Torvalds } 787ced22070SDavid Woodhouse mutex_unlock(&victim_f->sem); 7881da177e4SLinus Torvalds } 7891da177e4SLinus Torvalds } 7901da177e4SLinus Torvalds 7911da177e4SLinus Torvalds /* XXX: We probably ought to alloc enough space for 7921da177e4SLinus Torvalds both nodes at the same time. Writing the new link, 7931da177e4SLinus Torvalds then getting -ENOSPC, is quite bad :) 7941da177e4SLinus Torvalds */ 7951da177e4SLinus Torvalds 7961da177e4SLinus Torvalds /* Make a hard link */ 7971da177e4SLinus Torvalds 7981da177e4SLinus Torvalds /* XXX: This is ugly */ 7992b0143b5SDavid Howells type = (d_inode(old_dentry)->i_mode & S_IFMT) >> 12; 8001da177e4SLinus Torvalds if (!type) type = DT_REG; 8011da177e4SLinus Torvalds 8023a69e0cdSArtem B. Bityutskiy now = get_seconds(); 8031da177e4SLinus Torvalds ret = jffs2_do_link(c, JFFS2_INODE_INFO(new_dir_i), 8042b0143b5SDavid Howells d_inode(old_dentry)->i_ino, type, 8053a69e0cdSArtem B. Bityutskiy new_dentry->d_name.name, new_dentry->d_name.len, now); 8061da177e4SLinus Torvalds 8071da177e4SLinus Torvalds if (ret) 8081da177e4SLinus Torvalds return ret; 8091da177e4SLinus Torvalds 8101da177e4SLinus Torvalds if (victim_f) { 8111da177e4SLinus Torvalds /* There was a victim. Kill it off nicely */ 812e36cb0b8SDavid Howells if (d_is_dir(new_dentry)) 8132b0143b5SDavid Howells clear_nlink(d_inode(new_dentry)); 81422ba747fSAl Viro else 8152b0143b5SDavid Howells drop_nlink(d_inode(new_dentry)); 8161da177e4SLinus Torvalds /* Don't oops if the victim was a dirent pointing to an 8171da177e4SLinus Torvalds inode which didn't exist. */ 8181da177e4SLinus Torvalds if (victim_f->inocache) { 819ced22070SDavid Woodhouse mutex_lock(&victim_f->sem); 820e36cb0b8SDavid Howells if (d_is_dir(new_dentry)) 82127c72b04SDavid Woodhouse victim_f->inocache->pino_nlink = 0; 82227c72b04SDavid Woodhouse else 82327c72b04SDavid Woodhouse victim_f->inocache->pino_nlink--; 824ced22070SDavid Woodhouse mutex_unlock(&victim_f->sem); 8251da177e4SLinus Torvalds } 8261da177e4SLinus Torvalds } 8271da177e4SLinus Torvalds 8281da177e4SLinus Torvalds /* If it was a directory we moved, and there was no victim, 8291da177e4SLinus Torvalds increase i_nlink on its new parent */ 830e36cb0b8SDavid Howells if (d_is_dir(old_dentry) && !victim_f) 831d8c76e6fSDave Hansen inc_nlink(new_dir_i); 8321da177e4SLinus Torvalds 8331da177e4SLinus Torvalds /* Unlink the original */ 8341da177e4SLinus Torvalds ret = jffs2_do_unlink(c, JFFS2_INODE_INFO(old_dir_i), 8353a69e0cdSArtem B. Bityutskiy old_dentry->d_name.name, old_dentry->d_name.len, NULL, now); 8361da177e4SLinus Torvalds 8371da177e4SLinus Torvalds /* We don't touch inode->i_nlink */ 8381da177e4SLinus Torvalds 8391da177e4SLinus Torvalds if (ret) { 8401da177e4SLinus Torvalds /* Oh shit. We really ought to make a single node which can do both atomically */ 8412b0143b5SDavid Howells struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry)); 842ced22070SDavid Woodhouse mutex_lock(&f->sem); 8432b0143b5SDavid Howells inc_nlink(d_inode(old_dentry)); 844e36cb0b8SDavid Howells if (f->inocache && !d_is_dir(old_dentry)) 84527c72b04SDavid Woodhouse f->inocache->pino_nlink++; 846ced22070SDavid Woodhouse mutex_unlock(&f->sem); 8471da177e4SLinus Torvalds 848da320f05SJoe Perches pr_notice("%s(): Link succeeded, unlink failed (err %d). You now have a hard link\n", 849da320f05SJoe Perches __func__, ret); 850f9381284SAl Viro /* 851f9381284SAl Viro * We can't keep the target in dcache after that. 852f9381284SAl Viro * For one thing, we can't afford dentry aliases for directories. 853f9381284SAl Viro * For another, if there was a victim, we _can't_ set new inode 854f9381284SAl Viro * for that sucker and we have to trigger mount eviction - the 855f9381284SAl Viro * caller won't do it on its own since we are returning an error. 856f9381284SAl Viro */ 857f9381284SAl Viro d_invalidate(new_dentry); 8583a69e0cdSArtem B. Bityutskiy new_dir_i->i_mtime = new_dir_i->i_ctime = ITIME(now); 8591da177e4SLinus Torvalds return ret; 8601da177e4SLinus Torvalds } 8611da177e4SLinus Torvalds 862e36cb0b8SDavid Howells if (d_is_dir(old_dentry)) 8639a53c3a7SDave Hansen drop_nlink(old_dir_i); 8641da177e4SLinus Torvalds 8653a69e0cdSArtem B. Bityutskiy new_dir_i->i_mtime = new_dir_i->i_ctime = old_dir_i->i_mtime = old_dir_i->i_ctime = ITIME(now); 8663a69e0cdSArtem B. Bityutskiy 8671da177e4SLinus Torvalds return 0; 8681da177e4SLinus Torvalds } 8691da177e4SLinus Torvalds 870