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 *, 38f03b8ad8SMiklos Szeredi struct inode *, struct dentry *, 39f03b8ad8SMiklos Szeredi unsigned int); 401da177e4SLinus Torvalds 414b6f5d20SArjan van de Ven const struct file_operations jffs2_dir_operations = 421da177e4SLinus Torvalds { 431da177e4SLinus Torvalds .read = generic_read_dir, 44c51da20cSAl Viro .iterate_shared=jffs2_readdir, 450533400bSStoyan Gaydarov .unlocked_ioctl=jffs2_ioctl, 463222a3e5SChristoph Hellwig .fsync = jffs2_fsync, 473222a3e5SChristoph Hellwig .llseek = generic_file_llseek, 481da177e4SLinus Torvalds }; 491da177e4SLinus Torvalds 501da177e4SLinus Torvalds 5192e1d5beSArjan van de Ven const struct inode_operations jffs2_dir_inode_operations = 521da177e4SLinus Torvalds { 53265489f0SDavid Woodhouse .create = jffs2_create, 54265489f0SDavid Woodhouse .lookup = jffs2_lookup, 551da177e4SLinus Torvalds .link = jffs2_link, 561da177e4SLinus Torvalds .unlink = jffs2_unlink, 571da177e4SLinus Torvalds .symlink = jffs2_symlink, 581da177e4SLinus Torvalds .mkdir = jffs2_mkdir, 591da177e4SLinus Torvalds .rmdir = jffs2_rmdir, 601da177e4SLinus Torvalds .mknod = jffs2_mknod, 611da177e4SLinus Torvalds .rename = jffs2_rename, 624e34e719SChristoph Hellwig .get_acl = jffs2_get_acl, 63f2963d45SChristoph Hellwig .set_acl = jffs2_set_acl, 641da177e4SLinus Torvalds .setattr = jffs2_setattr, 65aa98d7cfSKaiGai Kohei .listxattr = jffs2_listxattr, 661da177e4SLinus Torvalds }; 671da177e4SLinus Torvalds 681da177e4SLinus Torvalds /***********************************************************************/ 691da177e4SLinus Torvalds 701da177e4SLinus Torvalds 711da177e4SLinus Torvalds /* We keep the dirent list sorted in increasing order of name hash, 721da177e4SLinus Torvalds and we use the same hash function as the dentries. Makes this 731da177e4SLinus Torvalds nice and simple 741da177e4SLinus Torvalds */ 751da177e4SLinus Torvalds static struct dentry *jffs2_lookup(struct inode *dir_i, struct dentry *target, 7600cd8dd3SAl Viro unsigned int flags) 771da177e4SLinus Torvalds { 781da177e4SLinus Torvalds struct jffs2_inode_info *dir_f; 791da177e4SLinus Torvalds struct jffs2_full_dirent *fd = NULL, *fd_list; 801da177e4SLinus Torvalds uint32_t ino = 0; 811da177e4SLinus Torvalds struct inode *inode = NULL; 828387ff25SLinus Torvalds unsigned int nhash; 831da177e4SLinus Torvalds 849c261b33SJoe Perches jffs2_dbg(1, "jffs2_lookup()\n"); 851da177e4SLinus Torvalds 86373d5e71SRichard Purdie if (target->d_name.len > JFFS2_MAX_NAME_LEN) 87373d5e71SRichard Purdie return ERR_PTR(-ENAMETOOLONG); 88373d5e71SRichard Purdie 891da177e4SLinus Torvalds dir_f = JFFS2_INODE_INFO(dir_i); 901da177e4SLinus Torvalds 918387ff25SLinus Torvalds /* The 'nhash' on the fd_list is not the same as the dentry hash */ 928387ff25SLinus Torvalds nhash = full_name_hash(NULL, target->d_name.name, target->d_name.len); 938387ff25SLinus Torvalds 94ced22070SDavid Woodhouse mutex_lock(&dir_f->sem); 951da177e4SLinus Torvalds 961da177e4SLinus Torvalds /* NB: The 2.2 backport will need to explicitly check for '.' and '..' here */ 978387ff25SLinus Torvalds for (fd_list = dir_f->dents; fd_list && fd_list->nhash <= nhash; fd_list = fd_list->next) { 988387ff25SLinus Torvalds if (fd_list->nhash == nhash && 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; 107ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 1081da177e4SLinus Torvalds if (ino) { 1095451f79fSDavid Howells inode = jffs2_iget(dir_i->i_sb, ino); 110a9049376SAl Viro if (IS_ERR(inode)) 111da320f05SJoe Perches pr_warn("iget() failed for ino #%u\n", ino); 1121da177e4SLinus Torvalds } 1131da177e4SLinus Torvalds 1148966c5e0SDavid Woodhouse return d_splice_alias(inode, target); 1151da177e4SLinus Torvalds } 1161da177e4SLinus Torvalds 1171da177e4SLinus Torvalds /***********************************************************************/ 1181da177e4SLinus Torvalds 1191da177e4SLinus Torvalds 1200312fa7cSAl Viro static int jffs2_readdir(struct file *file, struct dir_context *ctx) 1211da177e4SLinus Torvalds { 1220312fa7cSAl Viro struct inode *inode = file_inode(file); 1230312fa7cSAl Viro struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode); 1241da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 1250312fa7cSAl Viro unsigned long curofs = 1; 1261da177e4SLinus Torvalds 1270312fa7cSAl Viro jffs2_dbg(1, "jffs2_readdir() for dir_i #%lu\n", inode->i_ino); 1281da177e4SLinus Torvalds 1290312fa7cSAl Viro if (!dir_emit_dots(file, ctx)) 1300312fa7cSAl Viro return 0; 1311da177e4SLinus Torvalds 132ced22070SDavid Woodhouse mutex_lock(&f->sem); 1331da177e4SLinus Torvalds for (fd = f->dents; fd; fd = fd->next) { 1341da177e4SLinus Torvalds curofs++; 1350312fa7cSAl Viro /* First loop: curofs = 2; pos = 2 */ 1360312fa7cSAl Viro if (curofs < ctx->pos) { 1379c261b33SJoe Perches jffs2_dbg(2, "Skipping dirent: \"%s\", ino #%u, type %d, because curofs %ld < offset %ld\n", 1380312fa7cSAl Viro fd->name, fd->ino, fd->type, curofs, (unsigned long)ctx->pos); 1391da177e4SLinus Torvalds continue; 1401da177e4SLinus Torvalds } 1411da177e4SLinus Torvalds if (!fd->ino) { 1429c261b33SJoe Perches jffs2_dbg(2, "Skipping deletion dirent \"%s\"\n", 1439c261b33SJoe Perches fd->name); 1440312fa7cSAl Viro ctx->pos++; 1451da177e4SLinus Torvalds continue; 1461da177e4SLinus Torvalds } 1479c261b33SJoe Perches jffs2_dbg(2, "Dirent %ld: \"%s\", ino #%u, type %d\n", 1480312fa7cSAl Viro (unsigned long)ctx->pos, fd->name, fd->ino, fd->type); 1490312fa7cSAl Viro if (!dir_emit(ctx, fd->name, strlen(fd->name), fd->ino, fd->type)) 1501da177e4SLinus Torvalds break; 1510312fa7cSAl Viro ctx->pos++; 1521da177e4SLinus Torvalds } 153ced22070SDavid Woodhouse mutex_unlock(&f->sem); 1541da177e4SLinus Torvalds return 0; 1551da177e4SLinus Torvalds } 1561da177e4SLinus Torvalds 1571da177e4SLinus Torvalds /***********************************************************************/ 1581da177e4SLinus Torvalds 1591da177e4SLinus Torvalds 1604acdaf27SAl Viro static int jffs2_create(struct inode *dir_i, struct dentry *dentry, 161ebfc3b49SAl Viro umode_t mode, bool excl) 1621da177e4SLinus Torvalds { 1631da177e4SLinus Torvalds struct jffs2_raw_inode *ri; 1641da177e4SLinus Torvalds struct jffs2_inode_info *f, *dir_f; 1651da177e4SLinus Torvalds struct jffs2_sb_info *c; 1661da177e4SLinus Torvalds struct inode *inode; 1671da177e4SLinus Torvalds int ret; 1681da177e4SLinus Torvalds 1691da177e4SLinus Torvalds ri = jffs2_alloc_raw_inode(); 1701da177e4SLinus Torvalds if (!ri) 1711da177e4SLinus Torvalds return -ENOMEM; 1721da177e4SLinus Torvalds 1731da177e4SLinus Torvalds c = JFFS2_SB_INFO(dir_i->i_sb); 1741da177e4SLinus Torvalds 1759c261b33SJoe Perches jffs2_dbg(1, "%s()\n", __func__); 1761da177e4SLinus Torvalds 177cfc8dc6fSKaiGai Kohei inode = jffs2_new_inode(dir_i, mode, ri); 1781da177e4SLinus Torvalds 1791da177e4SLinus Torvalds if (IS_ERR(inode)) { 1809c261b33SJoe Perches jffs2_dbg(1, "jffs2_new_inode() failed\n"); 1811da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 1821da177e4SLinus Torvalds return PTR_ERR(inode); 1831da177e4SLinus Torvalds } 1841da177e4SLinus Torvalds 1851da177e4SLinus Torvalds inode->i_op = &jffs2_file_inode_operations; 1861da177e4SLinus Torvalds inode->i_fop = &jffs2_file_operations; 1871da177e4SLinus Torvalds inode->i_mapping->a_ops = &jffs2_file_address_operations; 1881da177e4SLinus Torvalds inode->i_mapping->nrpages = 0; 1891da177e4SLinus Torvalds 1901da177e4SLinus Torvalds f = JFFS2_INODE_INFO(inode); 1911da177e4SLinus Torvalds dir_f = JFFS2_INODE_INFO(dir_i); 1921da177e4SLinus Torvalds 193590fe34cSDavid Woodhouse /* jffs2_do_create() will want to lock it, _after_ reserving 194590fe34cSDavid Woodhouse space and taking c-alloc_sem. If we keep it locked here, 195590fe34cSDavid Woodhouse lockdep gets unhappy (although it's a false positive; 196590fe34cSDavid Woodhouse nothing else will be looking at this inode yet so there's 197590fe34cSDavid Woodhouse no chance of AB-BA deadlock involving its f->sem). */ 198590fe34cSDavid Woodhouse mutex_unlock(&f->sem); 199590fe34cSDavid Woodhouse 2002a7dba39SEric Paris ret = jffs2_do_create(c, dir_f, f, ri, &dentry->d_name); 201aa98d7cfSKaiGai Kohei if (ret) 202aa98d7cfSKaiGai Kohei goto fail; 2031da177e4SLinus Torvalds 204c4592b9cSArnd Bergmann dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(ri->ctime)); 2051da177e4SLinus Torvalds 2061da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 2071da177e4SLinus Torvalds 2089c261b33SJoe Perches jffs2_dbg(1, "%s(): Created ino #%lu with mode %o, nlink %d(%d). nrpages %ld\n", 2099c261b33SJoe Perches __func__, inode->i_ino, inode->i_mode, inode->i_nlink, 2109c261b33SJoe Perches f->inocache->pino_nlink, inode->i_mapping->nrpages); 211e72e6497SDavid Woodhouse 2121e2e547aSAl Viro d_instantiate_new(dentry, inode); 2131da177e4SLinus Torvalds return 0; 214aa98d7cfSKaiGai Kohei 215aa98d7cfSKaiGai Kohei fail: 21641cce647SAl Viro iget_failed(inode); 217aa98d7cfSKaiGai Kohei jffs2_free_raw_inode(ri); 218aa98d7cfSKaiGai Kohei return ret; 2191da177e4SLinus Torvalds } 2201da177e4SLinus Torvalds 2211da177e4SLinus Torvalds /***********************************************************************/ 2221da177e4SLinus Torvalds 2231da177e4SLinus Torvalds 2241da177e4SLinus Torvalds static int jffs2_unlink(struct inode *dir_i, struct dentry *dentry) 2251da177e4SLinus Torvalds { 2261da177e4SLinus Torvalds struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb); 2271da177e4SLinus Torvalds struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); 2282b0143b5SDavid Howells struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(d_inode(dentry)); 2291da177e4SLinus Torvalds int ret; 230c4592b9cSArnd Bergmann uint32_t now = JFFS2_NOW(); 2311da177e4SLinus Torvalds 2321da177e4SLinus Torvalds ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name, 2333a69e0cdSArtem B. Bityutskiy dentry->d_name.len, dead_f, now); 2341da177e4SLinus Torvalds if (dead_f->inocache) 2352b0143b5SDavid Howells set_nlink(d_inode(dentry), dead_f->inocache->pino_nlink); 2363a69e0cdSArtem B. Bityutskiy if (!ret) 237c4592b9cSArnd Bergmann dir_i->i_mtime = dir_i->i_ctime = ITIME(now); 2381da177e4SLinus Torvalds return ret; 2391da177e4SLinus Torvalds } 2401da177e4SLinus Torvalds /***********************************************************************/ 2411da177e4SLinus Torvalds 2421da177e4SLinus Torvalds 2431da177e4SLinus Torvalds static int jffs2_link (struct dentry *old_dentry, struct inode *dir_i, struct dentry *dentry) 2441da177e4SLinus Torvalds { 245fc64005cSAl Viro struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dentry->d_sb); 2462b0143b5SDavid Howells struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry)); 2471da177e4SLinus Torvalds struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); 2481da177e4SLinus Torvalds int ret; 2491da177e4SLinus Torvalds uint8_t type; 2503a69e0cdSArtem B. Bityutskiy uint32_t now; 2511da177e4SLinus Torvalds 2521da177e4SLinus Torvalds /* Don't let people make hard links to bad inodes. */ 2531da177e4SLinus Torvalds if (!f->inocache) 2541da177e4SLinus Torvalds return -EIO; 2551da177e4SLinus Torvalds 256e36cb0b8SDavid Howells if (d_is_dir(old_dentry)) 2571da177e4SLinus Torvalds return -EPERM; 2581da177e4SLinus Torvalds 2591da177e4SLinus Torvalds /* XXX: This is ugly */ 2602b0143b5SDavid Howells type = (d_inode(old_dentry)->i_mode & S_IFMT) >> 12; 2611da177e4SLinus Torvalds if (!type) type = DT_REG; 2621da177e4SLinus Torvalds 263c4592b9cSArnd Bergmann now = JFFS2_NOW(); 2643a69e0cdSArtem B. Bityutskiy ret = jffs2_do_link(c, dir_f, f->inocache->ino, type, dentry->d_name.name, dentry->d_name.len, now); 2651da177e4SLinus Torvalds 2661da177e4SLinus Torvalds if (!ret) { 267ced22070SDavid Woodhouse mutex_lock(&f->sem); 2682b0143b5SDavid Howells set_nlink(d_inode(old_dentry), ++f->inocache->pino_nlink); 269ced22070SDavid Woodhouse mutex_unlock(&f->sem); 2702b0143b5SDavid Howells d_instantiate(dentry, d_inode(old_dentry)); 271c4592b9cSArnd Bergmann dir_i->i_mtime = dir_i->i_ctime = ITIME(now); 2722b0143b5SDavid Howells ihold(d_inode(old_dentry)); 2731da177e4SLinus Torvalds } 2741da177e4SLinus Torvalds return ret; 2751da177e4SLinus Torvalds } 2761da177e4SLinus Torvalds 2771da177e4SLinus Torvalds /***********************************************************************/ 2781da177e4SLinus Torvalds 2791da177e4SLinus Torvalds static int jffs2_symlink (struct inode *dir_i, struct dentry *dentry, const char *target) 2801da177e4SLinus Torvalds { 2811da177e4SLinus Torvalds struct jffs2_inode_info *f, *dir_f; 2821da177e4SLinus Torvalds struct jffs2_sb_info *c; 2831da177e4SLinus Torvalds struct inode *inode; 2841da177e4SLinus Torvalds struct jffs2_raw_inode *ri; 2851da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 2861da177e4SLinus Torvalds struct jffs2_full_dnode *fn; 2871da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 2881da177e4SLinus Torvalds int namelen; 2899fe4854cSDavid Woodhouse uint32_t alloclen; 29032f1a95dSArtem B. Bityuckiy int ret, targetlen = strlen(target); 2911da177e4SLinus Torvalds 2921da177e4SLinus Torvalds /* FIXME: If you care. We'd need to use frags for the target 2931da177e4SLinus Torvalds if it grows much more than this */ 29432f1a95dSArtem B. Bityuckiy if (targetlen > 254) 295bde86fecSAdrian Hunter return -ENAMETOOLONG; 2961da177e4SLinus Torvalds 2971da177e4SLinus Torvalds ri = jffs2_alloc_raw_inode(); 2981da177e4SLinus Torvalds 2991da177e4SLinus Torvalds if (!ri) 3001da177e4SLinus Torvalds return -ENOMEM; 3011da177e4SLinus Torvalds 3021da177e4SLinus Torvalds c = JFFS2_SB_INFO(dir_i->i_sb); 3031da177e4SLinus Torvalds 3041da177e4SLinus Torvalds /* Try to reserve enough space for both node and dirent. 3051da177e4SLinus Torvalds * Just the node will do for now, though 3061da177e4SLinus Torvalds */ 3071da177e4SLinus Torvalds namelen = dentry->d_name.len; 3089fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*ri) + targetlen, &alloclen, 309e631ddbaSFerenc Havasi ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE); 3101da177e4SLinus Torvalds 3111da177e4SLinus Torvalds if (ret) { 3121da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 3131da177e4SLinus Torvalds return ret; 3141da177e4SLinus Torvalds } 3151da177e4SLinus Torvalds 316cfc8dc6fSKaiGai Kohei inode = jffs2_new_inode(dir_i, S_IFLNK | S_IRWXUGO, ri); 3171da177e4SLinus Torvalds 3181da177e4SLinus Torvalds if (IS_ERR(inode)) { 3191da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 3201da177e4SLinus Torvalds jffs2_complete_reservation(c); 3211da177e4SLinus Torvalds return PTR_ERR(inode); 3221da177e4SLinus Torvalds } 3231da177e4SLinus Torvalds 3241da177e4SLinus Torvalds inode->i_op = &jffs2_symlink_inode_operations; 3251da177e4SLinus Torvalds 3261da177e4SLinus Torvalds f = JFFS2_INODE_INFO(inode); 3271da177e4SLinus Torvalds 32832f1a95dSArtem B. Bityuckiy inode->i_size = targetlen; 3291da177e4SLinus Torvalds ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size); 3301da177e4SLinus Torvalds ri->totlen = cpu_to_je32(sizeof(*ri) + inode->i_size); 3311da177e4SLinus Torvalds ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 3321da177e4SLinus Torvalds 3331da177e4SLinus Torvalds ri->compr = JFFS2_COMPR_NONE; 33432f1a95dSArtem B. Bityuckiy ri->data_crc = cpu_to_je32(crc32(0, target, targetlen)); 3351da177e4SLinus Torvalds ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 3361da177e4SLinus Torvalds 3379fe4854cSDavid Woodhouse fn = jffs2_write_dnode(c, f, ri, target, targetlen, ALLOC_NORMAL); 3381da177e4SLinus Torvalds 3391da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 3401da177e4SLinus Torvalds 3411da177e4SLinus Torvalds if (IS_ERR(fn)) { 3421da177e4SLinus Torvalds /* Eeek. Wave bye bye */ 343ced22070SDavid Woodhouse mutex_unlock(&f->sem); 3441da177e4SLinus Torvalds jffs2_complete_reservation(c); 345f324e4cbSDavid Woodhouse ret = PTR_ERR(fn); 346f324e4cbSDavid Woodhouse goto fail; 3471da177e4SLinus Torvalds } 34832f1a95dSArtem B. Bityuckiy 3492b79adccSArtem B. Bityutskiy /* We use f->target field to store the target path. */ 35004aadf36SJulia Lawall f->target = kmemdup(target, targetlen + 1, GFP_KERNEL); 3512b79adccSArtem B. Bityutskiy if (!f->target) { 352da320f05SJoe Perches pr_warn("Can't allocate %d bytes of memory\n", targetlen + 1); 353ced22070SDavid Woodhouse mutex_unlock(&f->sem); 35432f1a95dSArtem B. Bityuckiy jffs2_complete_reservation(c); 355f324e4cbSDavid Woodhouse ret = -ENOMEM; 356f324e4cbSDavid Woodhouse goto fail; 35732f1a95dSArtem B. Bityuckiy } 358a8db149fSAl Viro inode->i_link = f->target; 35932f1a95dSArtem B. Bityuckiy 3609c261b33SJoe Perches jffs2_dbg(1, "%s(): symlink's target '%s' cached\n", 3619c261b33SJoe Perches __func__, (char *)f->target); 36232f1a95dSArtem B. Bityuckiy 3631da177e4SLinus Torvalds /* No data here. Only a metadata node, which will be 3641da177e4SLinus Torvalds obsoleted by the first data write 3651da177e4SLinus Torvalds */ 3661da177e4SLinus Torvalds f->metadata = fn; 367ced22070SDavid Woodhouse mutex_unlock(&f->sem); 3681da177e4SLinus Torvalds 3691da177e4SLinus Torvalds jffs2_complete_reservation(c); 370aa98d7cfSKaiGai Kohei 3712a7dba39SEric Paris ret = jffs2_init_security(inode, dir_i, &dentry->d_name); 372f324e4cbSDavid Woodhouse if (ret) 373f324e4cbSDavid Woodhouse goto fail; 374f324e4cbSDavid Woodhouse 375cfc8dc6fSKaiGai Kohei ret = jffs2_init_acl_post(inode); 376f324e4cbSDavid Woodhouse if (ret) 377f324e4cbSDavid Woodhouse goto fail; 378aa98d7cfSKaiGai Kohei 3799fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 380e631ddbaSFerenc Havasi ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 381f324e4cbSDavid Woodhouse if (ret) 382f324e4cbSDavid Woodhouse goto fail; 3831da177e4SLinus Torvalds 3841da177e4SLinus Torvalds rd = jffs2_alloc_raw_dirent(); 3851da177e4SLinus Torvalds if (!rd) { 3861da177e4SLinus Torvalds /* Argh. Now we treat it like a normal delete */ 3871da177e4SLinus Torvalds jffs2_complete_reservation(c); 388f324e4cbSDavid Woodhouse ret = -ENOMEM; 389f324e4cbSDavid Woodhouse goto fail; 3901da177e4SLinus Torvalds } 3911da177e4SLinus Torvalds 3921da177e4SLinus Torvalds dir_f = JFFS2_INODE_INFO(dir_i); 393ced22070SDavid Woodhouse mutex_lock(&dir_f->sem); 3941da177e4SLinus Torvalds 3951da177e4SLinus Torvalds rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 3961da177e4SLinus Torvalds rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 3971da177e4SLinus Torvalds rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 3981da177e4SLinus Torvalds rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 3991da177e4SLinus Torvalds 4001da177e4SLinus Torvalds rd->pino = cpu_to_je32(dir_i->i_ino); 4011da177e4SLinus Torvalds rd->version = cpu_to_je32(++dir_f->highest_version); 4021da177e4SLinus Torvalds rd->ino = cpu_to_je32(inode->i_ino); 403c4592b9cSArnd Bergmann rd->mctime = cpu_to_je32(JFFS2_NOW()); 4041da177e4SLinus Torvalds rd->nsize = namelen; 4051da177e4SLinus Torvalds rd->type = DT_LNK; 4061da177e4SLinus Torvalds rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 4071da177e4SLinus Torvalds rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen)); 4081da177e4SLinus Torvalds 4099fe4854cSDavid Woodhouse fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL); 4101da177e4SLinus Torvalds 4111da177e4SLinus Torvalds if (IS_ERR(fd)) { 4121da177e4SLinus Torvalds /* dirent failed to write. Delete the inode normally 4131da177e4SLinus Torvalds as if it were the final unlink() */ 4141da177e4SLinus Torvalds jffs2_complete_reservation(c); 4151da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 416ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 417f324e4cbSDavid Woodhouse ret = PTR_ERR(fd); 418f324e4cbSDavid Woodhouse goto fail; 4191da177e4SLinus Torvalds } 4201da177e4SLinus Torvalds 421c4592b9cSArnd Bergmann dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime)); 4221da177e4SLinus Torvalds 4231da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 4241da177e4SLinus Torvalds 4251da177e4SLinus Torvalds /* Link the fd into the inode's list, obsoleting an old 4261da177e4SLinus Torvalds one if necessary. */ 4271da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &dir_f->dents); 4281da177e4SLinus Torvalds 429ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 4301da177e4SLinus Torvalds jffs2_complete_reservation(c); 4311da177e4SLinus Torvalds 4321e2e547aSAl Viro d_instantiate_new(dentry, inode); 4331da177e4SLinus Torvalds return 0; 434f324e4cbSDavid Woodhouse 435f324e4cbSDavid Woodhouse fail: 43641cce647SAl Viro iget_failed(inode); 437f324e4cbSDavid Woodhouse return ret; 4381da177e4SLinus Torvalds } 4391da177e4SLinus Torvalds 4401da177e4SLinus Torvalds 44118bb1db3SAl Viro static int jffs2_mkdir (struct inode *dir_i, struct dentry *dentry, umode_t mode) 4421da177e4SLinus Torvalds { 4431da177e4SLinus Torvalds struct jffs2_inode_info *f, *dir_f; 4441da177e4SLinus Torvalds struct jffs2_sb_info *c; 4451da177e4SLinus Torvalds struct inode *inode; 4461da177e4SLinus Torvalds struct jffs2_raw_inode *ri; 4471da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 4481da177e4SLinus Torvalds struct jffs2_full_dnode *fn; 4491da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 4501da177e4SLinus Torvalds int namelen; 4519fe4854cSDavid Woodhouse uint32_t alloclen; 4521da177e4SLinus Torvalds int ret; 4531da177e4SLinus Torvalds 4541da177e4SLinus Torvalds mode |= S_IFDIR; 4551da177e4SLinus Torvalds 4561da177e4SLinus Torvalds ri = jffs2_alloc_raw_inode(); 4571da177e4SLinus Torvalds if (!ri) 4581da177e4SLinus Torvalds return -ENOMEM; 4591da177e4SLinus Torvalds 4601da177e4SLinus Torvalds c = JFFS2_SB_INFO(dir_i->i_sb); 4611da177e4SLinus Torvalds 4621da177e4SLinus Torvalds /* Try to reserve enough space for both node and dirent. 4631da177e4SLinus Torvalds * Just the node will do for now, though 4641da177e4SLinus Torvalds */ 4651da177e4SLinus Torvalds namelen = dentry->d_name.len; 4669fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL, 467e631ddbaSFerenc Havasi JFFS2_SUMMARY_INODE_SIZE); 4681da177e4SLinus Torvalds 4691da177e4SLinus Torvalds if (ret) { 4701da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 4711da177e4SLinus Torvalds return ret; 4721da177e4SLinus Torvalds } 4731da177e4SLinus Torvalds 474cfc8dc6fSKaiGai Kohei inode = jffs2_new_inode(dir_i, mode, ri); 4751da177e4SLinus Torvalds 4761da177e4SLinus Torvalds if (IS_ERR(inode)) { 4771da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 4781da177e4SLinus Torvalds jffs2_complete_reservation(c); 4791da177e4SLinus Torvalds return PTR_ERR(inode); 4801da177e4SLinus Torvalds } 4811da177e4SLinus Torvalds 4821da177e4SLinus Torvalds inode->i_op = &jffs2_dir_inode_operations; 4831da177e4SLinus Torvalds inode->i_fop = &jffs2_dir_operations; 4841da177e4SLinus Torvalds 4851da177e4SLinus Torvalds f = JFFS2_INODE_INFO(inode); 4861da177e4SLinus Torvalds 48727c72b04SDavid Woodhouse /* Directories get nlink 2 at start */ 488bfe86848SMiklos Szeredi set_nlink(inode, 2); 48927c72b04SDavid Woodhouse /* but ic->pino_nlink is the parent ino# */ 49027c72b04SDavid Woodhouse f->inocache->pino_nlink = dir_i->i_ino; 49127c72b04SDavid Woodhouse 4921da177e4SLinus Torvalds ri->data_crc = cpu_to_je32(0); 4931da177e4SLinus Torvalds ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 4941da177e4SLinus Torvalds 4959fe4854cSDavid Woodhouse fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL); 4961da177e4SLinus Torvalds 4971da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 4981da177e4SLinus Torvalds 4991da177e4SLinus Torvalds if (IS_ERR(fn)) { 5001da177e4SLinus Torvalds /* Eeek. Wave bye bye */ 501ced22070SDavid Woodhouse mutex_unlock(&f->sem); 5021da177e4SLinus Torvalds jffs2_complete_reservation(c); 503f324e4cbSDavid Woodhouse ret = PTR_ERR(fn); 504f324e4cbSDavid Woodhouse goto fail; 5051da177e4SLinus Torvalds } 5061da177e4SLinus Torvalds /* No data here. Only a metadata node, which will be 5071da177e4SLinus Torvalds obsoleted by the first data write 5081da177e4SLinus Torvalds */ 5091da177e4SLinus Torvalds f->metadata = fn; 510ced22070SDavid Woodhouse mutex_unlock(&f->sem); 5111da177e4SLinus Torvalds 5121da177e4SLinus Torvalds jffs2_complete_reservation(c); 513aa98d7cfSKaiGai Kohei 5142a7dba39SEric Paris ret = jffs2_init_security(inode, dir_i, &dentry->d_name); 515f324e4cbSDavid Woodhouse if (ret) 516f324e4cbSDavid Woodhouse goto fail; 517f324e4cbSDavid Woodhouse 518cfc8dc6fSKaiGai Kohei ret = jffs2_init_acl_post(inode); 519f324e4cbSDavid Woodhouse if (ret) 520f324e4cbSDavid Woodhouse goto fail; 521aa98d7cfSKaiGai Kohei 5229fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 523e631ddbaSFerenc Havasi ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 524f324e4cbSDavid Woodhouse if (ret) 525f324e4cbSDavid Woodhouse goto fail; 5261da177e4SLinus Torvalds 5271da177e4SLinus Torvalds rd = jffs2_alloc_raw_dirent(); 5281da177e4SLinus Torvalds if (!rd) { 5291da177e4SLinus Torvalds /* Argh. Now we treat it like a normal delete */ 5301da177e4SLinus Torvalds jffs2_complete_reservation(c); 531f324e4cbSDavid Woodhouse ret = -ENOMEM; 532f324e4cbSDavid Woodhouse goto fail; 5331da177e4SLinus Torvalds } 5341da177e4SLinus Torvalds 5351da177e4SLinus Torvalds dir_f = JFFS2_INODE_INFO(dir_i); 536ced22070SDavid Woodhouse mutex_lock(&dir_f->sem); 5371da177e4SLinus Torvalds 5381da177e4SLinus Torvalds rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 5391da177e4SLinus Torvalds rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 5401da177e4SLinus Torvalds rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 5411da177e4SLinus Torvalds rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 5421da177e4SLinus Torvalds 5431da177e4SLinus Torvalds rd->pino = cpu_to_je32(dir_i->i_ino); 5441da177e4SLinus Torvalds rd->version = cpu_to_je32(++dir_f->highest_version); 5451da177e4SLinus Torvalds rd->ino = cpu_to_je32(inode->i_ino); 546c4592b9cSArnd Bergmann rd->mctime = cpu_to_je32(JFFS2_NOW()); 5471da177e4SLinus Torvalds rd->nsize = namelen; 5481da177e4SLinus Torvalds rd->type = DT_DIR; 5491da177e4SLinus Torvalds rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 5501da177e4SLinus Torvalds rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen)); 5511da177e4SLinus Torvalds 5529fe4854cSDavid Woodhouse fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL); 5531da177e4SLinus Torvalds 5541da177e4SLinus Torvalds if (IS_ERR(fd)) { 5551da177e4SLinus Torvalds /* dirent failed to write. Delete the inode normally 5561da177e4SLinus Torvalds as if it were the final unlink() */ 5571da177e4SLinus Torvalds jffs2_complete_reservation(c); 5581da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 559ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 560f324e4cbSDavid Woodhouse ret = PTR_ERR(fd); 561f324e4cbSDavid Woodhouse goto fail; 5621da177e4SLinus Torvalds } 5631da177e4SLinus Torvalds 564c4592b9cSArnd Bergmann dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime)); 565d8c76e6fSDave Hansen inc_nlink(dir_i); 5661da177e4SLinus Torvalds 5671da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 5681da177e4SLinus Torvalds 5691da177e4SLinus Torvalds /* Link the fd into the inode's list, obsoleting an old 5701da177e4SLinus Torvalds one if necessary. */ 5711da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &dir_f->dents); 5721da177e4SLinus Torvalds 573ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 5741da177e4SLinus Torvalds jffs2_complete_reservation(c); 5751da177e4SLinus Torvalds 5761e2e547aSAl Viro d_instantiate_new(dentry, inode); 5771da177e4SLinus Torvalds return 0; 578f324e4cbSDavid Woodhouse 579f324e4cbSDavid Woodhouse fail: 58041cce647SAl Viro iget_failed(inode); 581f324e4cbSDavid Woodhouse return ret; 5821da177e4SLinus Torvalds } 5831da177e4SLinus Torvalds 5841da177e4SLinus Torvalds static int jffs2_rmdir (struct inode *dir_i, struct dentry *dentry) 5851da177e4SLinus Torvalds { 58627c72b04SDavid Woodhouse struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb); 58727c72b04SDavid Woodhouse struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); 5882b0143b5SDavid Howells struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(dentry)); 5891da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 5901da177e4SLinus Torvalds int ret; 591c4592b9cSArnd Bergmann uint32_t now = JFFS2_NOW(); 5921da177e4SLinus Torvalds 593*798b7347SZhe Li mutex_lock(&f->sem); 5941da177e4SLinus Torvalds for (fd = f->dents ; fd; fd = fd->next) { 595*798b7347SZhe Li if (fd->ino) { 596*798b7347SZhe Li mutex_unlock(&f->sem); 5971da177e4SLinus Torvalds return -ENOTEMPTY; 5981da177e4SLinus Torvalds } 599*798b7347SZhe Li } 600*798b7347SZhe Li mutex_unlock(&f->sem); 60127c72b04SDavid Woodhouse 60227c72b04SDavid Woodhouse ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name, 60327c72b04SDavid Woodhouse dentry->d_name.len, f, now); 60427c72b04SDavid Woodhouse if (!ret) { 605c4592b9cSArnd Bergmann dir_i->i_mtime = dir_i->i_ctime = ITIME(now); 6062b0143b5SDavid Howells clear_nlink(d_inode(dentry)); 6079a53c3a7SDave Hansen drop_nlink(dir_i); 60827c72b04SDavid Woodhouse } 6091da177e4SLinus Torvalds return ret; 6101da177e4SLinus Torvalds } 6111da177e4SLinus Torvalds 6121a67aafbSAl Viro static int jffs2_mknod (struct inode *dir_i, struct dentry *dentry, umode_t mode, dev_t rdev) 6131da177e4SLinus Torvalds { 6141da177e4SLinus Torvalds struct jffs2_inode_info *f, *dir_f; 6151da177e4SLinus Torvalds struct jffs2_sb_info *c; 6161da177e4SLinus Torvalds struct inode *inode; 6171da177e4SLinus Torvalds struct jffs2_raw_inode *ri; 6181da177e4SLinus Torvalds struct jffs2_raw_dirent *rd; 6191da177e4SLinus Torvalds struct jffs2_full_dnode *fn; 6201da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 6211da177e4SLinus Torvalds int namelen; 622aef9ab47SDavid Woodhouse union jffs2_device_node dev; 6231da177e4SLinus Torvalds int devlen = 0; 6249fe4854cSDavid Woodhouse uint32_t alloclen; 6251da177e4SLinus Torvalds int ret; 6261da177e4SLinus Torvalds 6271da177e4SLinus Torvalds ri = jffs2_alloc_raw_inode(); 6281da177e4SLinus Torvalds if (!ri) 6291da177e4SLinus Torvalds return -ENOMEM; 6301da177e4SLinus Torvalds 6311da177e4SLinus Torvalds c = JFFS2_SB_INFO(dir_i->i_sb); 6321da177e4SLinus Torvalds 633aef9ab47SDavid Woodhouse if (S_ISBLK(mode) || S_ISCHR(mode)) 634aef9ab47SDavid Woodhouse devlen = jffs2_encode_dev(&dev, rdev); 6351da177e4SLinus Torvalds 6361da177e4SLinus Torvalds /* Try to reserve enough space for both node and dirent. 6371da177e4SLinus Torvalds * Just the node will do for now, though 6381da177e4SLinus Torvalds */ 6391da177e4SLinus Torvalds namelen = dentry->d_name.len; 6409fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*ri) + devlen, &alloclen, 641e631ddbaSFerenc Havasi ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE); 6421da177e4SLinus Torvalds 6431da177e4SLinus Torvalds if (ret) { 6441da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 6451da177e4SLinus Torvalds return ret; 6461da177e4SLinus Torvalds } 6471da177e4SLinus Torvalds 648cfc8dc6fSKaiGai Kohei inode = jffs2_new_inode(dir_i, mode, ri); 6491da177e4SLinus Torvalds 6501da177e4SLinus Torvalds if (IS_ERR(inode)) { 6511da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 6521da177e4SLinus Torvalds jffs2_complete_reservation(c); 6531da177e4SLinus Torvalds return PTR_ERR(inode); 6541da177e4SLinus Torvalds } 6551da177e4SLinus Torvalds inode->i_op = &jffs2_file_inode_operations; 6561da177e4SLinus Torvalds init_special_inode(inode, inode->i_mode, rdev); 6571da177e4SLinus Torvalds 6581da177e4SLinus Torvalds f = JFFS2_INODE_INFO(inode); 6591da177e4SLinus Torvalds 6601da177e4SLinus Torvalds ri->dsize = ri->csize = cpu_to_je32(devlen); 6611da177e4SLinus Torvalds ri->totlen = cpu_to_je32(sizeof(*ri) + devlen); 6621da177e4SLinus Torvalds ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 6631da177e4SLinus Torvalds 6641da177e4SLinus Torvalds ri->compr = JFFS2_COMPR_NONE; 6651da177e4SLinus Torvalds ri->data_crc = cpu_to_je32(crc32(0, &dev, devlen)); 6661da177e4SLinus Torvalds ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 6671da177e4SLinus Torvalds 6689fe4854cSDavid Woodhouse fn = jffs2_write_dnode(c, f, ri, (char *)&dev, devlen, ALLOC_NORMAL); 6691da177e4SLinus Torvalds 6701da177e4SLinus Torvalds jffs2_free_raw_inode(ri); 6711da177e4SLinus Torvalds 6721da177e4SLinus Torvalds if (IS_ERR(fn)) { 6731da177e4SLinus Torvalds /* Eeek. Wave bye bye */ 674ced22070SDavid Woodhouse mutex_unlock(&f->sem); 6751da177e4SLinus Torvalds jffs2_complete_reservation(c); 676f324e4cbSDavid Woodhouse ret = PTR_ERR(fn); 677f324e4cbSDavid Woodhouse goto fail; 6781da177e4SLinus Torvalds } 6791da177e4SLinus Torvalds /* No data here. Only a metadata node, which will be 6801da177e4SLinus Torvalds obsoleted by the first data write 6811da177e4SLinus Torvalds */ 6821da177e4SLinus Torvalds f->metadata = fn; 683ced22070SDavid Woodhouse mutex_unlock(&f->sem); 6841da177e4SLinus Torvalds 6851da177e4SLinus Torvalds jffs2_complete_reservation(c); 686aa98d7cfSKaiGai Kohei 6872a7dba39SEric Paris ret = jffs2_init_security(inode, dir_i, &dentry->d_name); 688f324e4cbSDavid Woodhouse if (ret) 689f324e4cbSDavid Woodhouse goto fail; 690f324e4cbSDavid Woodhouse 691cfc8dc6fSKaiGai Kohei ret = jffs2_init_acl_post(inode); 692f324e4cbSDavid Woodhouse if (ret) 693f324e4cbSDavid Woodhouse goto fail; 694aa98d7cfSKaiGai Kohei 6959fe4854cSDavid Woodhouse ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 696e631ddbaSFerenc Havasi ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 697f324e4cbSDavid Woodhouse if (ret) 698f324e4cbSDavid Woodhouse goto fail; 6991da177e4SLinus Torvalds 7001da177e4SLinus Torvalds rd = jffs2_alloc_raw_dirent(); 7011da177e4SLinus Torvalds if (!rd) { 7021da177e4SLinus Torvalds /* Argh. Now we treat it like a normal delete */ 7031da177e4SLinus Torvalds jffs2_complete_reservation(c); 704f324e4cbSDavid Woodhouse ret = -ENOMEM; 705f324e4cbSDavid Woodhouse goto fail; 7061da177e4SLinus Torvalds } 7071da177e4SLinus Torvalds 7081da177e4SLinus Torvalds dir_f = JFFS2_INODE_INFO(dir_i); 709ced22070SDavid Woodhouse mutex_lock(&dir_f->sem); 7101da177e4SLinus Torvalds 7111da177e4SLinus Torvalds rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 7121da177e4SLinus Torvalds rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); 7131da177e4SLinus Torvalds rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 7141da177e4SLinus Torvalds rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 7151da177e4SLinus Torvalds 7161da177e4SLinus Torvalds rd->pino = cpu_to_je32(dir_i->i_ino); 7171da177e4SLinus Torvalds rd->version = cpu_to_je32(++dir_f->highest_version); 7181da177e4SLinus Torvalds rd->ino = cpu_to_je32(inode->i_ino); 719c4592b9cSArnd Bergmann rd->mctime = cpu_to_je32(JFFS2_NOW()); 7201da177e4SLinus Torvalds rd->nsize = namelen; 7211da177e4SLinus Torvalds 7221da177e4SLinus Torvalds /* XXX: This is ugly. */ 7231da177e4SLinus Torvalds rd->type = (mode & S_IFMT) >> 12; 7241da177e4SLinus Torvalds 7251da177e4SLinus Torvalds rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 7261da177e4SLinus Torvalds rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen)); 7271da177e4SLinus Torvalds 7289fe4854cSDavid Woodhouse fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL); 7291da177e4SLinus Torvalds 7301da177e4SLinus Torvalds if (IS_ERR(fd)) { 7311da177e4SLinus Torvalds /* dirent failed to write. Delete the inode normally 7321da177e4SLinus Torvalds as if it were the final unlink() */ 7331da177e4SLinus Torvalds jffs2_complete_reservation(c); 7341da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 735ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 736f324e4cbSDavid Woodhouse ret = PTR_ERR(fd); 737f324e4cbSDavid Woodhouse goto fail; 7381da177e4SLinus Torvalds } 7391da177e4SLinus Torvalds 740c4592b9cSArnd Bergmann dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime)); 7411da177e4SLinus Torvalds 7421da177e4SLinus Torvalds jffs2_free_raw_dirent(rd); 7431da177e4SLinus Torvalds 7441da177e4SLinus Torvalds /* Link the fd into the inode's list, obsoleting an old 7451da177e4SLinus Torvalds one if necessary. */ 7461da177e4SLinus Torvalds jffs2_add_fd_to_list(c, fd, &dir_f->dents); 7471da177e4SLinus Torvalds 748ced22070SDavid Woodhouse mutex_unlock(&dir_f->sem); 7491da177e4SLinus Torvalds jffs2_complete_reservation(c); 7501da177e4SLinus Torvalds 7511e2e547aSAl Viro d_instantiate_new(dentry, inode); 7521da177e4SLinus Torvalds return 0; 753f324e4cbSDavid Woodhouse 754f324e4cbSDavid Woodhouse fail: 75541cce647SAl Viro iget_failed(inode); 756f324e4cbSDavid Woodhouse return ret; 7571da177e4SLinus Torvalds } 7581da177e4SLinus Torvalds 7591da177e4SLinus Torvalds static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry, 760f03b8ad8SMiklos Szeredi struct inode *new_dir_i, struct dentry *new_dentry, 761f03b8ad8SMiklos Szeredi unsigned int flags) 7621da177e4SLinus Torvalds { 7631da177e4SLinus Torvalds int ret; 7641da177e4SLinus Torvalds struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dir_i->i_sb); 7651da177e4SLinus Torvalds struct jffs2_inode_info *victim_f = NULL; 7661da177e4SLinus Torvalds uint8_t type; 7673a69e0cdSArtem B. Bityutskiy uint32_t now; 7681da177e4SLinus Torvalds 769f03b8ad8SMiklos Szeredi if (flags & ~RENAME_NOREPLACE) 770f03b8ad8SMiklos Szeredi return -EINVAL; 771f03b8ad8SMiklos Szeredi 7721da177e4SLinus Torvalds /* The VFS will check for us and prevent trying to rename a 7731da177e4SLinus Torvalds * file over a directory and vice versa, but if it's a directory, 7741da177e4SLinus Torvalds * the VFS can't check whether the victim is empty. The filesystem 7751da177e4SLinus Torvalds * needs to do that for itself. 7761da177e4SLinus Torvalds */ 7772b0143b5SDavid Howells if (d_really_is_positive(new_dentry)) { 7782b0143b5SDavid Howells victim_f = JFFS2_INODE_INFO(d_inode(new_dentry)); 779e36cb0b8SDavid Howells if (d_is_dir(new_dentry)) { 7801da177e4SLinus Torvalds struct jffs2_full_dirent *fd; 7811da177e4SLinus Torvalds 782ced22070SDavid Woodhouse mutex_lock(&victim_f->sem); 7831da177e4SLinus Torvalds for (fd = victim_f->dents; fd; fd = fd->next) { 7841da177e4SLinus Torvalds if (fd->ino) { 785ced22070SDavid Woodhouse mutex_unlock(&victim_f->sem); 7861da177e4SLinus Torvalds return -ENOTEMPTY; 7871da177e4SLinus Torvalds } 7881da177e4SLinus Torvalds } 789ced22070SDavid Woodhouse mutex_unlock(&victim_f->sem); 7901da177e4SLinus Torvalds } 7911da177e4SLinus Torvalds } 7921da177e4SLinus Torvalds 7931da177e4SLinus Torvalds /* XXX: We probably ought to alloc enough space for 7941da177e4SLinus Torvalds both nodes at the same time. Writing the new link, 7951da177e4SLinus Torvalds then getting -ENOSPC, is quite bad :) 7961da177e4SLinus Torvalds */ 7971da177e4SLinus Torvalds 7981da177e4SLinus Torvalds /* Make a hard link */ 7991da177e4SLinus Torvalds 8001da177e4SLinus Torvalds /* XXX: This is ugly */ 8012b0143b5SDavid Howells type = (d_inode(old_dentry)->i_mode & S_IFMT) >> 12; 8021da177e4SLinus Torvalds if (!type) type = DT_REG; 8031da177e4SLinus Torvalds 804c4592b9cSArnd Bergmann now = JFFS2_NOW(); 8051da177e4SLinus Torvalds ret = jffs2_do_link(c, JFFS2_INODE_INFO(new_dir_i), 8062b0143b5SDavid Howells d_inode(old_dentry)->i_ino, type, 8073a69e0cdSArtem B. Bityutskiy new_dentry->d_name.name, new_dentry->d_name.len, now); 8081da177e4SLinus Torvalds 8091da177e4SLinus Torvalds if (ret) 8101da177e4SLinus Torvalds return ret; 8111da177e4SLinus Torvalds 8121da177e4SLinus Torvalds if (victim_f) { 8131da177e4SLinus Torvalds /* There was a victim. Kill it off nicely */ 814e36cb0b8SDavid Howells if (d_is_dir(new_dentry)) 8152b0143b5SDavid Howells clear_nlink(d_inode(new_dentry)); 81622ba747fSAl Viro else 8172b0143b5SDavid Howells drop_nlink(d_inode(new_dentry)); 8181da177e4SLinus Torvalds /* Don't oops if the victim was a dirent pointing to an 8191da177e4SLinus Torvalds inode which didn't exist. */ 8201da177e4SLinus Torvalds if (victim_f->inocache) { 821ced22070SDavid Woodhouse mutex_lock(&victim_f->sem); 822e36cb0b8SDavid Howells if (d_is_dir(new_dentry)) 82327c72b04SDavid Woodhouse victim_f->inocache->pino_nlink = 0; 82427c72b04SDavid Woodhouse else 82527c72b04SDavid Woodhouse victim_f->inocache->pino_nlink--; 826ced22070SDavid Woodhouse mutex_unlock(&victim_f->sem); 8271da177e4SLinus Torvalds } 8281da177e4SLinus Torvalds } 8291da177e4SLinus Torvalds 8301da177e4SLinus Torvalds /* If it was a directory we moved, and there was no victim, 8311da177e4SLinus Torvalds increase i_nlink on its new parent */ 832e36cb0b8SDavid Howells if (d_is_dir(old_dentry) && !victim_f) 833d8c76e6fSDave Hansen inc_nlink(new_dir_i); 8341da177e4SLinus Torvalds 8351da177e4SLinus Torvalds /* Unlink the original */ 8361da177e4SLinus Torvalds ret = jffs2_do_unlink(c, JFFS2_INODE_INFO(old_dir_i), 8373a69e0cdSArtem B. Bityutskiy old_dentry->d_name.name, old_dentry->d_name.len, NULL, now); 8381da177e4SLinus Torvalds 8391da177e4SLinus Torvalds /* We don't touch inode->i_nlink */ 8401da177e4SLinus Torvalds 8411da177e4SLinus Torvalds if (ret) { 8421da177e4SLinus Torvalds /* Oh shit. We really ought to make a single node which can do both atomically */ 8432b0143b5SDavid Howells struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry)); 844ced22070SDavid Woodhouse mutex_lock(&f->sem); 8452b0143b5SDavid Howells inc_nlink(d_inode(old_dentry)); 846e36cb0b8SDavid Howells if (f->inocache && !d_is_dir(old_dentry)) 84727c72b04SDavid Woodhouse f->inocache->pino_nlink++; 848ced22070SDavid Woodhouse mutex_unlock(&f->sem); 8491da177e4SLinus Torvalds 850da320f05SJoe Perches pr_notice("%s(): Link succeeded, unlink failed (err %d). You now have a hard link\n", 851da320f05SJoe Perches __func__, ret); 852f9381284SAl Viro /* 853f9381284SAl Viro * We can't keep the target in dcache after that. 854f9381284SAl Viro * For one thing, we can't afford dentry aliases for directories. 855f9381284SAl Viro * For another, if there was a victim, we _can't_ set new inode 856f9381284SAl Viro * for that sucker and we have to trigger mount eviction - the 857f9381284SAl Viro * caller won't do it on its own since we are returning an error. 858f9381284SAl Viro */ 859f9381284SAl Viro d_invalidate(new_dentry); 860c4592b9cSArnd Bergmann new_dir_i->i_mtime = new_dir_i->i_ctime = ITIME(now); 8611da177e4SLinus Torvalds return ret; 8621da177e4SLinus Torvalds } 8631da177e4SLinus Torvalds 864e36cb0b8SDavid Howells if (d_is_dir(old_dentry)) 8659a53c3a7SDave Hansen drop_nlink(old_dir_i); 8661da177e4SLinus Torvalds 867c4592b9cSArnd Bergmann new_dir_i->i_mtime = new_dir_i->i_ctime = old_dir_i->i_mtime = old_dir_i->i_ctime = ITIME(now); 8683a69e0cdSArtem B. Bityutskiy 8691da177e4SLinus Torvalds return 0; 8701da177e4SLinus Torvalds } 8711da177e4SLinus Torvalds 872