x86/mm/pat: Don't report PAT on CPUs that don't support it
[linux/fpc-iii.git] / fs / jffs2 / dir.c
blob0a754f38462e9623e5608e65f95606abfef453be
1 /*
2 * JFFS2 -- Journalling Flash File System, Version 2.
4 * Copyright © 2001-2007 Red Hat, Inc.
5 * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org>
7 * Created by David Woodhouse <dwmw2@infradead.org>
9 * For licensing information, see the file 'LICENCE' in this directory.
13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15 #include <linux/kernel.h>
16 #include <linux/slab.h>
17 #include <linux/fs.h>
18 #include <linux/crc32.h>
19 #include <linux/jffs2.h>
20 #include "jffs2_fs_i.h"
21 #include "jffs2_fs_sb.h"
22 #include <linux/time.h>
23 #include "nodelist.h"
25 static int jffs2_readdir (struct file *, struct dir_context *);
27 static int jffs2_create (struct inode *,struct dentry *,umode_t,
28 bool);
29 static struct dentry *jffs2_lookup (struct inode *,struct dentry *,
30 unsigned int);
31 static int jffs2_link (struct dentry *,struct inode *,struct dentry *);
32 static int jffs2_unlink (struct inode *,struct dentry *);
33 static int jffs2_symlink (struct inode *,struct dentry *,const char *);
34 static int jffs2_mkdir (struct inode *,struct dentry *,umode_t);
35 static int jffs2_rmdir (struct inode *,struct dentry *);
36 static int jffs2_mknod (struct inode *,struct dentry *,umode_t,dev_t);
37 static int jffs2_rename (struct inode *, struct dentry *,
38 struct inode *, struct dentry *,
39 unsigned int);
41 const struct file_operations jffs2_dir_operations =
43 .read = generic_read_dir,
44 .iterate_shared=jffs2_readdir,
45 .unlocked_ioctl=jffs2_ioctl,
46 .fsync = jffs2_fsync,
47 .llseek = generic_file_llseek,
51 const struct inode_operations jffs2_dir_inode_operations =
53 .create = jffs2_create,
54 .lookup = jffs2_lookup,
55 .link = jffs2_link,
56 .unlink = jffs2_unlink,
57 .symlink = jffs2_symlink,
58 .mkdir = jffs2_mkdir,
59 .rmdir = jffs2_rmdir,
60 .mknod = jffs2_mknod,
61 .rename = jffs2_rename,
62 .get_acl = jffs2_get_acl,
63 .set_acl = jffs2_set_acl,
64 .setattr = jffs2_setattr,
65 .listxattr = jffs2_listxattr,
68 /***********************************************************************/
71 /* We keep the dirent list sorted in increasing order of name hash,
72 and we use the same hash function as the dentries. Makes this
73 nice and simple
75 static struct dentry *jffs2_lookup(struct inode *dir_i, struct dentry *target,
76 unsigned int flags)
78 struct jffs2_inode_info *dir_f;
79 struct jffs2_full_dirent *fd = NULL, *fd_list;
80 uint32_t ino = 0;
81 struct inode *inode = NULL;
82 unsigned int nhash;
84 jffs2_dbg(1, "jffs2_lookup()\n");
86 if (target->d_name.len > JFFS2_MAX_NAME_LEN)
87 return ERR_PTR(-ENAMETOOLONG);
89 dir_f = JFFS2_INODE_INFO(dir_i);
91 /* The 'nhash' on the fd_list is not the same as the dentry hash */
92 nhash = full_name_hash(NULL, target->d_name.name, target->d_name.len);
94 mutex_lock(&dir_f->sem);
96 /* NB: The 2.2 backport will need to explicitly check for '.' and '..' here */
97 for (fd_list = dir_f->dents; fd_list && fd_list->nhash <= nhash; fd_list = fd_list->next) {
98 if (fd_list->nhash == nhash &&
99 (!fd || fd_list->version > fd->version) &&
100 strlen(fd_list->name) == target->d_name.len &&
101 !strncmp(fd_list->name, target->d_name.name, target->d_name.len)) {
102 fd = fd_list;
105 if (fd)
106 ino = fd->ino;
107 mutex_unlock(&dir_f->sem);
108 if (ino) {
109 inode = jffs2_iget(dir_i->i_sb, ino);
110 if (IS_ERR(inode))
111 pr_warn("iget() failed for ino #%u\n", ino);
114 return d_splice_alias(inode, target);
117 /***********************************************************************/
120 static int jffs2_readdir(struct file *file, struct dir_context *ctx)
122 struct inode *inode = file_inode(file);
123 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
124 struct jffs2_full_dirent *fd;
125 unsigned long curofs = 1;
127 jffs2_dbg(1, "jffs2_readdir() for dir_i #%lu\n", inode->i_ino);
129 if (!dir_emit_dots(file, ctx))
130 return 0;
132 mutex_lock(&f->sem);
133 for (fd = f->dents; fd; fd = fd->next) {
134 curofs++;
135 /* First loop: curofs = 2; pos = 2 */
136 if (curofs < ctx->pos) {
137 jffs2_dbg(2, "Skipping dirent: \"%s\", ino #%u, type %d, because curofs %ld < offset %ld\n",
138 fd->name, fd->ino, fd->type, curofs, (unsigned long)ctx->pos);
139 continue;
141 if (!fd->ino) {
142 jffs2_dbg(2, "Skipping deletion dirent \"%s\"\n",
143 fd->name);
144 ctx->pos++;
145 continue;
147 jffs2_dbg(2, "Dirent %ld: \"%s\", ino #%u, type %d\n",
148 (unsigned long)ctx->pos, fd->name, fd->ino, fd->type);
149 if (!dir_emit(ctx, fd->name, strlen(fd->name), fd->ino, fd->type))
150 break;
151 ctx->pos++;
153 mutex_unlock(&f->sem);
154 return 0;
157 /***********************************************************************/
160 static int jffs2_create(struct inode *dir_i, struct dentry *dentry,
161 umode_t mode, bool excl)
163 struct jffs2_raw_inode *ri;
164 struct jffs2_inode_info *f, *dir_f;
165 struct jffs2_sb_info *c;
166 struct inode *inode;
167 int ret;
169 ri = jffs2_alloc_raw_inode();
170 if (!ri)
171 return -ENOMEM;
173 c = JFFS2_SB_INFO(dir_i->i_sb);
175 jffs2_dbg(1, "%s()\n", __func__);
177 inode = jffs2_new_inode(dir_i, mode, ri);
179 if (IS_ERR(inode)) {
180 jffs2_dbg(1, "jffs2_new_inode() failed\n");
181 jffs2_free_raw_inode(ri);
182 return PTR_ERR(inode);
185 inode->i_op = &jffs2_file_inode_operations;
186 inode->i_fop = &jffs2_file_operations;
187 inode->i_mapping->a_ops = &jffs2_file_address_operations;
188 inode->i_mapping->nrpages = 0;
190 f = JFFS2_INODE_INFO(inode);
191 dir_f = JFFS2_INODE_INFO(dir_i);
193 /* jffs2_do_create() will want to lock it, _after_ reserving
194 space and taking c-alloc_sem. If we keep it locked here,
195 lockdep gets unhappy (although it's a false positive;
196 nothing else will be looking at this inode yet so there's
197 no chance of AB-BA deadlock involving its f->sem). */
198 mutex_unlock(&f->sem);
200 ret = jffs2_do_create(c, dir_f, f, ri, &dentry->d_name);
201 if (ret)
202 goto fail;
204 dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(ri->ctime));
206 jffs2_free_raw_inode(ri);
208 jffs2_dbg(1, "%s(): Created ino #%lu with mode %o, nlink %d(%d). nrpages %ld\n",
209 __func__, inode->i_ino, inode->i_mode, inode->i_nlink,
210 f->inocache->pino_nlink, inode->i_mapping->nrpages);
212 unlock_new_inode(inode);
213 d_instantiate(dentry, inode);
214 return 0;
216 fail:
217 iget_failed(inode);
218 jffs2_free_raw_inode(ri);
219 return ret;
222 /***********************************************************************/
225 static int jffs2_unlink(struct inode *dir_i, struct dentry *dentry)
227 struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb);
228 struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
229 struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(d_inode(dentry));
230 int ret;
231 uint32_t now = get_seconds();
233 ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name,
234 dentry->d_name.len, dead_f, now);
235 if (dead_f->inocache)
236 set_nlink(d_inode(dentry), dead_f->inocache->pino_nlink);
237 if (!ret)
238 dir_i->i_mtime = dir_i->i_ctime = ITIME(now);
239 return ret;
241 /***********************************************************************/
244 static int jffs2_link (struct dentry *old_dentry, struct inode *dir_i, struct dentry *dentry)
246 struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dentry->d_sb);
247 struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry));
248 struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
249 int ret;
250 uint8_t type;
251 uint32_t now;
253 /* Don't let people make hard links to bad inodes. */
254 if (!f->inocache)
255 return -EIO;
257 if (d_is_dir(old_dentry))
258 return -EPERM;
260 /* XXX: This is ugly */
261 type = (d_inode(old_dentry)->i_mode & S_IFMT) >> 12;
262 if (!type) type = DT_REG;
264 now = get_seconds();
265 ret = jffs2_do_link(c, dir_f, f->inocache->ino, type, dentry->d_name.name, dentry->d_name.len, now);
267 if (!ret) {
268 mutex_lock(&f->sem);
269 set_nlink(d_inode(old_dentry), ++f->inocache->pino_nlink);
270 mutex_unlock(&f->sem);
271 d_instantiate(dentry, d_inode(old_dentry));
272 dir_i->i_mtime = dir_i->i_ctime = ITIME(now);
273 ihold(d_inode(old_dentry));
275 return ret;
278 /***********************************************************************/
280 static int jffs2_symlink (struct inode *dir_i, struct dentry *dentry, const char *target)
282 struct jffs2_inode_info *f, *dir_f;
283 struct jffs2_sb_info *c;
284 struct inode *inode;
285 struct jffs2_raw_inode *ri;
286 struct jffs2_raw_dirent *rd;
287 struct jffs2_full_dnode *fn;
288 struct jffs2_full_dirent *fd;
289 int namelen;
290 uint32_t alloclen;
291 int ret, targetlen = strlen(target);
293 /* FIXME: If you care. We'd need to use frags for the target
294 if it grows much more than this */
295 if (targetlen > 254)
296 return -ENAMETOOLONG;
298 ri = jffs2_alloc_raw_inode();
300 if (!ri)
301 return -ENOMEM;
303 c = JFFS2_SB_INFO(dir_i->i_sb);
305 /* Try to reserve enough space for both node and dirent.
306 * Just the node will do for now, though
308 namelen = dentry->d_name.len;
309 ret = jffs2_reserve_space(c, sizeof(*ri) + targetlen, &alloclen,
310 ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
312 if (ret) {
313 jffs2_free_raw_inode(ri);
314 return ret;
317 inode = jffs2_new_inode(dir_i, S_IFLNK | S_IRWXUGO, ri);
319 if (IS_ERR(inode)) {
320 jffs2_free_raw_inode(ri);
321 jffs2_complete_reservation(c);
322 return PTR_ERR(inode);
325 inode->i_op = &jffs2_symlink_inode_operations;
327 f = JFFS2_INODE_INFO(inode);
329 inode->i_size = targetlen;
330 ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size);
331 ri->totlen = cpu_to_je32(sizeof(*ri) + inode->i_size);
332 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
334 ri->compr = JFFS2_COMPR_NONE;
335 ri->data_crc = cpu_to_je32(crc32(0, target, targetlen));
336 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
338 fn = jffs2_write_dnode(c, f, ri, target, targetlen, ALLOC_NORMAL);
340 jffs2_free_raw_inode(ri);
342 if (IS_ERR(fn)) {
343 /* Eeek. Wave bye bye */
344 mutex_unlock(&f->sem);
345 jffs2_complete_reservation(c);
346 ret = PTR_ERR(fn);
347 goto fail;
350 /* We use f->target field to store the target path. */
351 f->target = kmemdup(target, targetlen + 1, GFP_KERNEL);
352 if (!f->target) {
353 pr_warn("Can't allocate %d bytes of memory\n", targetlen + 1);
354 mutex_unlock(&f->sem);
355 jffs2_complete_reservation(c);
356 ret = -ENOMEM;
357 goto fail;
359 inode->i_link = f->target;
361 jffs2_dbg(1, "%s(): symlink's target '%s' cached\n",
362 __func__, (char *)f->target);
364 /* No data here. Only a metadata node, which will be
365 obsoleted by the first data write
367 f->metadata = fn;
368 mutex_unlock(&f->sem);
370 jffs2_complete_reservation(c);
372 ret = jffs2_init_security(inode, dir_i, &dentry->d_name);
373 if (ret)
374 goto fail;
376 ret = jffs2_init_acl_post(inode);
377 if (ret)
378 goto fail;
380 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
381 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
382 if (ret)
383 goto fail;
385 rd = jffs2_alloc_raw_dirent();
386 if (!rd) {
387 /* Argh. Now we treat it like a normal delete */
388 jffs2_complete_reservation(c);
389 ret = -ENOMEM;
390 goto fail;
393 dir_f = JFFS2_INODE_INFO(dir_i);
394 mutex_lock(&dir_f->sem);
396 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
397 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
398 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
399 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
401 rd->pino = cpu_to_je32(dir_i->i_ino);
402 rd->version = cpu_to_je32(++dir_f->highest_version);
403 rd->ino = cpu_to_je32(inode->i_ino);
404 rd->mctime = cpu_to_je32(get_seconds());
405 rd->nsize = namelen;
406 rd->type = DT_LNK;
407 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
408 rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen));
410 fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL);
412 if (IS_ERR(fd)) {
413 /* dirent failed to write. Delete the inode normally
414 as if it were the final unlink() */
415 jffs2_complete_reservation(c);
416 jffs2_free_raw_dirent(rd);
417 mutex_unlock(&dir_f->sem);
418 ret = PTR_ERR(fd);
419 goto fail;
422 dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime));
424 jffs2_free_raw_dirent(rd);
426 /* Link the fd into the inode's list, obsoleting an old
427 one if necessary. */
428 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
430 mutex_unlock(&dir_f->sem);
431 jffs2_complete_reservation(c);
433 unlock_new_inode(inode);
434 d_instantiate(dentry, inode);
435 return 0;
437 fail:
438 iget_failed(inode);
439 return ret;
443 static int jffs2_mkdir (struct inode *dir_i, struct dentry *dentry, umode_t mode)
445 struct jffs2_inode_info *f, *dir_f;
446 struct jffs2_sb_info *c;
447 struct inode *inode;
448 struct jffs2_raw_inode *ri;
449 struct jffs2_raw_dirent *rd;
450 struct jffs2_full_dnode *fn;
451 struct jffs2_full_dirent *fd;
452 int namelen;
453 uint32_t alloclen;
454 int ret;
456 mode |= S_IFDIR;
458 ri = jffs2_alloc_raw_inode();
459 if (!ri)
460 return -ENOMEM;
462 c = JFFS2_SB_INFO(dir_i->i_sb);
464 /* Try to reserve enough space for both node and dirent.
465 * Just the node will do for now, though
467 namelen = dentry->d_name.len;
468 ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL,
469 JFFS2_SUMMARY_INODE_SIZE);
471 if (ret) {
472 jffs2_free_raw_inode(ri);
473 return ret;
476 inode = jffs2_new_inode(dir_i, mode, ri);
478 if (IS_ERR(inode)) {
479 jffs2_free_raw_inode(ri);
480 jffs2_complete_reservation(c);
481 return PTR_ERR(inode);
484 inode->i_op = &jffs2_dir_inode_operations;
485 inode->i_fop = &jffs2_dir_operations;
487 f = JFFS2_INODE_INFO(inode);
489 /* Directories get nlink 2 at start */
490 set_nlink(inode, 2);
491 /* but ic->pino_nlink is the parent ino# */
492 f->inocache->pino_nlink = dir_i->i_ino;
494 ri->data_crc = cpu_to_je32(0);
495 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
497 fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL);
499 jffs2_free_raw_inode(ri);
501 if (IS_ERR(fn)) {
502 /* Eeek. Wave bye bye */
503 mutex_unlock(&f->sem);
504 jffs2_complete_reservation(c);
505 ret = PTR_ERR(fn);
506 goto fail;
508 /* No data here. Only a metadata node, which will be
509 obsoleted by the first data write
511 f->metadata = fn;
512 mutex_unlock(&f->sem);
514 jffs2_complete_reservation(c);
516 ret = jffs2_init_security(inode, dir_i, &dentry->d_name);
517 if (ret)
518 goto fail;
520 ret = jffs2_init_acl_post(inode);
521 if (ret)
522 goto fail;
524 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
525 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
526 if (ret)
527 goto fail;
529 rd = jffs2_alloc_raw_dirent();
530 if (!rd) {
531 /* Argh. Now we treat it like a normal delete */
532 jffs2_complete_reservation(c);
533 ret = -ENOMEM;
534 goto fail;
537 dir_f = JFFS2_INODE_INFO(dir_i);
538 mutex_lock(&dir_f->sem);
540 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
541 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
542 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
543 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
545 rd->pino = cpu_to_je32(dir_i->i_ino);
546 rd->version = cpu_to_je32(++dir_f->highest_version);
547 rd->ino = cpu_to_je32(inode->i_ino);
548 rd->mctime = cpu_to_je32(get_seconds());
549 rd->nsize = namelen;
550 rd->type = DT_DIR;
551 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
552 rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen));
554 fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL);
556 if (IS_ERR(fd)) {
557 /* dirent failed to write. Delete the inode normally
558 as if it were the final unlink() */
559 jffs2_complete_reservation(c);
560 jffs2_free_raw_dirent(rd);
561 mutex_unlock(&dir_f->sem);
562 ret = PTR_ERR(fd);
563 goto fail;
566 dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime));
567 inc_nlink(dir_i);
569 jffs2_free_raw_dirent(rd);
571 /* Link the fd into the inode's list, obsoleting an old
572 one if necessary. */
573 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
575 mutex_unlock(&dir_f->sem);
576 jffs2_complete_reservation(c);
578 unlock_new_inode(inode);
579 d_instantiate(dentry, inode);
580 return 0;
582 fail:
583 iget_failed(inode);
584 return ret;
587 static int jffs2_rmdir (struct inode *dir_i, struct dentry *dentry)
589 struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb);
590 struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
591 struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(dentry));
592 struct jffs2_full_dirent *fd;
593 int ret;
594 uint32_t now = get_seconds();
596 for (fd = f->dents ; fd; fd = fd->next) {
597 if (fd->ino)
598 return -ENOTEMPTY;
601 ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name,
602 dentry->d_name.len, f, now);
603 if (!ret) {
604 dir_i->i_mtime = dir_i->i_ctime = ITIME(now);
605 clear_nlink(d_inode(dentry));
606 drop_nlink(dir_i);
608 return ret;
611 static int jffs2_mknod (struct inode *dir_i, struct dentry *dentry, umode_t mode, dev_t rdev)
613 struct jffs2_inode_info *f, *dir_f;
614 struct jffs2_sb_info *c;
615 struct inode *inode;
616 struct jffs2_raw_inode *ri;
617 struct jffs2_raw_dirent *rd;
618 struct jffs2_full_dnode *fn;
619 struct jffs2_full_dirent *fd;
620 int namelen;
621 union jffs2_device_node dev;
622 int devlen = 0;
623 uint32_t alloclen;
624 int ret;
626 ri = jffs2_alloc_raw_inode();
627 if (!ri)
628 return -ENOMEM;
630 c = JFFS2_SB_INFO(dir_i->i_sb);
632 if (S_ISBLK(mode) || S_ISCHR(mode))
633 devlen = jffs2_encode_dev(&dev, rdev);
635 /* Try to reserve enough space for both node and dirent.
636 * Just the node will do for now, though
638 namelen = dentry->d_name.len;
639 ret = jffs2_reserve_space(c, sizeof(*ri) + devlen, &alloclen,
640 ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
642 if (ret) {
643 jffs2_free_raw_inode(ri);
644 return ret;
647 inode = jffs2_new_inode(dir_i, mode, ri);
649 if (IS_ERR(inode)) {
650 jffs2_free_raw_inode(ri);
651 jffs2_complete_reservation(c);
652 return PTR_ERR(inode);
654 inode->i_op = &jffs2_file_inode_operations;
655 init_special_inode(inode, inode->i_mode, rdev);
657 f = JFFS2_INODE_INFO(inode);
659 ri->dsize = ri->csize = cpu_to_je32(devlen);
660 ri->totlen = cpu_to_je32(sizeof(*ri) + devlen);
661 ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
663 ri->compr = JFFS2_COMPR_NONE;
664 ri->data_crc = cpu_to_je32(crc32(0, &dev, devlen));
665 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
667 fn = jffs2_write_dnode(c, f, ri, (char *)&dev, devlen, ALLOC_NORMAL);
669 jffs2_free_raw_inode(ri);
671 if (IS_ERR(fn)) {
672 /* Eeek. Wave bye bye */
673 mutex_unlock(&f->sem);
674 jffs2_complete_reservation(c);
675 ret = PTR_ERR(fn);
676 goto fail;
678 /* No data here. Only a metadata node, which will be
679 obsoleted by the first data write
681 f->metadata = fn;
682 mutex_unlock(&f->sem);
684 jffs2_complete_reservation(c);
686 ret = jffs2_init_security(inode, dir_i, &dentry->d_name);
687 if (ret)
688 goto fail;
690 ret = jffs2_init_acl_post(inode);
691 if (ret)
692 goto fail;
694 ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
695 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
696 if (ret)
697 goto fail;
699 rd = jffs2_alloc_raw_dirent();
700 if (!rd) {
701 /* Argh. Now we treat it like a normal delete */
702 jffs2_complete_reservation(c);
703 ret = -ENOMEM;
704 goto fail;
707 dir_f = JFFS2_INODE_INFO(dir_i);
708 mutex_lock(&dir_f->sem);
710 rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
711 rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
712 rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
713 rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
715 rd->pino = cpu_to_je32(dir_i->i_ino);
716 rd->version = cpu_to_je32(++dir_f->highest_version);
717 rd->ino = cpu_to_je32(inode->i_ino);
718 rd->mctime = cpu_to_je32(get_seconds());
719 rd->nsize = namelen;
721 /* XXX: This is ugly. */
722 rd->type = (mode & S_IFMT) >> 12;
724 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
725 rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen));
727 fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL);
729 if (IS_ERR(fd)) {
730 /* dirent failed to write. Delete the inode normally
731 as if it were the final unlink() */
732 jffs2_complete_reservation(c);
733 jffs2_free_raw_dirent(rd);
734 mutex_unlock(&dir_f->sem);
735 ret = PTR_ERR(fd);
736 goto fail;
739 dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime));
741 jffs2_free_raw_dirent(rd);
743 /* Link the fd into the inode's list, obsoleting an old
744 one if necessary. */
745 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
747 mutex_unlock(&dir_f->sem);
748 jffs2_complete_reservation(c);
750 unlock_new_inode(inode);
751 d_instantiate(dentry, inode);
752 return 0;
754 fail:
755 iget_failed(inode);
756 return ret;
759 static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry,
760 struct inode *new_dir_i, struct dentry *new_dentry,
761 unsigned int flags)
763 int ret;
764 struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dir_i->i_sb);
765 struct jffs2_inode_info *victim_f = NULL;
766 uint8_t type;
767 uint32_t now;
769 if (flags & ~RENAME_NOREPLACE)
770 return -EINVAL;
772 /* The VFS will check for us and prevent trying to rename a
773 * file over a directory and vice versa, but if it's a directory,
774 * the VFS can't check whether the victim is empty. The filesystem
775 * needs to do that for itself.
777 if (d_really_is_positive(new_dentry)) {
778 victim_f = JFFS2_INODE_INFO(d_inode(new_dentry));
779 if (d_is_dir(new_dentry)) {
780 struct jffs2_full_dirent *fd;
782 mutex_lock(&victim_f->sem);
783 for (fd = victim_f->dents; fd; fd = fd->next) {
784 if (fd->ino) {
785 mutex_unlock(&victim_f->sem);
786 return -ENOTEMPTY;
789 mutex_unlock(&victim_f->sem);
793 /* XXX: We probably ought to alloc enough space for
794 both nodes at the same time. Writing the new link,
795 then getting -ENOSPC, is quite bad :)
798 /* Make a hard link */
800 /* XXX: This is ugly */
801 type = (d_inode(old_dentry)->i_mode & S_IFMT) >> 12;
802 if (!type) type = DT_REG;
804 now = get_seconds();
805 ret = jffs2_do_link(c, JFFS2_INODE_INFO(new_dir_i),
806 d_inode(old_dentry)->i_ino, type,
807 new_dentry->d_name.name, new_dentry->d_name.len, now);
809 if (ret)
810 return ret;
812 if (victim_f) {
813 /* There was a victim. Kill it off nicely */
814 if (d_is_dir(new_dentry))
815 clear_nlink(d_inode(new_dentry));
816 else
817 drop_nlink(d_inode(new_dentry));
818 /* Don't oops if the victim was a dirent pointing to an
819 inode which didn't exist. */
820 if (victim_f->inocache) {
821 mutex_lock(&victim_f->sem);
822 if (d_is_dir(new_dentry))
823 victim_f->inocache->pino_nlink = 0;
824 else
825 victim_f->inocache->pino_nlink--;
826 mutex_unlock(&victim_f->sem);
830 /* If it was a directory we moved, and there was no victim,
831 increase i_nlink on its new parent */
832 if (d_is_dir(old_dentry) && !victim_f)
833 inc_nlink(new_dir_i);
835 /* Unlink the original */
836 ret = jffs2_do_unlink(c, JFFS2_INODE_INFO(old_dir_i),
837 old_dentry->d_name.name, old_dentry->d_name.len, NULL, now);
839 /* We don't touch inode->i_nlink */
841 if (ret) {
842 /* Oh shit. We really ought to make a single node which can do both atomically */
843 struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry));
844 mutex_lock(&f->sem);
845 inc_nlink(d_inode(old_dentry));
846 if (f->inocache && !d_is_dir(old_dentry))
847 f->inocache->pino_nlink++;
848 mutex_unlock(&f->sem);
850 pr_notice("%s(): Link succeeded, unlink failed (err %d). You now have a hard link\n",
851 __func__, ret);
853 * We can't keep the target in dcache after that.
854 * For one thing, we can't afford dentry aliases for directories.
855 * For another, if there was a victim, we _can't_ set new inode
856 * for that sucker and we have to trigger mount eviction - the
857 * caller won't do it on its own since we are returning an error.
859 d_invalidate(new_dentry);
860 new_dir_i->i_mtime = new_dir_i->i_ctime = ITIME(now);
861 return ret;
864 if (d_is_dir(old_dentry))
865 drop_nlink(old_dir_i);
867 new_dir_i->i_mtime = new_dir_i->i_ctime = old_dir_i->i_mtime = old_dir_i->i_ctime = ITIME(now);
869 return 0;