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>
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>
25 static int jffs2_readdir (struct file
*, struct dir_context
*);
27 static int jffs2_create (struct inode
*,struct dentry
*,umode_t
,
29 static struct dentry
*jffs2_lookup (struct inode
*,struct dentry
*,
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
*);
40 const struct file_operations jffs2_dir_operations
=
42 .read
= generic_read_dir
,
43 .iterate_shared
=jffs2_readdir
,
44 .unlocked_ioctl
=jffs2_ioctl
,
46 .llseek
= generic_file_llseek
,
50 const struct inode_operations jffs2_dir_inode_operations
=
52 .create
= jffs2_create
,
53 .lookup
= jffs2_lookup
,
55 .unlink
= jffs2_unlink
,
56 .symlink
= jffs2_symlink
,
60 .rename
= jffs2_rename
,
61 .get_acl
= jffs2_get_acl
,
62 .set_acl
= jffs2_set_acl
,
63 .setattr
= jffs2_setattr
,
64 .setxattr
= jffs2_setxattr
,
65 .getxattr
= jffs2_getxattr
,
66 .listxattr
= jffs2_listxattr
,
67 .removexattr
= jffs2_removexattr
70 /***********************************************************************/
73 /* We keep the dirent list sorted in increasing order of name hash,
74 and we use the same hash function as the dentries. Makes this
77 static struct dentry
*jffs2_lookup(struct inode
*dir_i
, struct dentry
*target
,
80 struct jffs2_inode_info
*dir_f
;
81 struct jffs2_full_dirent
*fd
= NULL
, *fd_list
;
83 struct inode
*inode
= NULL
;
86 jffs2_dbg(1, "jffs2_lookup()\n");
88 if (target
->d_name
.len
> JFFS2_MAX_NAME_LEN
)
89 return ERR_PTR(-ENAMETOOLONG
);
91 dir_f
= JFFS2_INODE_INFO(dir_i
);
93 /* The 'nhash' on the fd_list is not the same as the dentry hash */
94 nhash
= full_name_hash(NULL
, target
->d_name
.name
, target
->d_name
.len
);
96 mutex_lock(&dir_f
->sem
);
98 /* NB: The 2.2 backport will need to explicitly check for '.' and '..' here */
99 for (fd_list
= dir_f
->dents
; fd_list
&& fd_list
->nhash
<= nhash
; fd_list
= fd_list
->next
) {
100 if (fd_list
->nhash
== nhash
&&
101 (!fd
|| fd_list
->version
> fd
->version
) &&
102 strlen(fd_list
->name
) == target
->d_name
.len
&&
103 !strncmp(fd_list
->name
, target
->d_name
.name
, target
->d_name
.len
)) {
109 mutex_unlock(&dir_f
->sem
);
111 inode
= jffs2_iget(dir_i
->i_sb
, ino
);
113 pr_warn("iget() failed for ino #%u\n", ino
);
116 return d_splice_alias(inode
, target
);
119 /***********************************************************************/
122 static int jffs2_readdir(struct file
*file
, struct dir_context
*ctx
)
124 struct inode
*inode
= file_inode(file
);
125 struct jffs2_inode_info
*f
= JFFS2_INODE_INFO(inode
);
126 struct jffs2_full_dirent
*fd
;
127 unsigned long curofs
= 1;
129 jffs2_dbg(1, "jffs2_readdir() for dir_i #%lu\n", inode
->i_ino
);
131 if (!dir_emit_dots(file
, ctx
))
135 for (fd
= f
->dents
; fd
; fd
= fd
->next
) {
137 /* First loop: curofs = 2; pos = 2 */
138 if (curofs
< ctx
->pos
) {
139 jffs2_dbg(2, "Skipping dirent: \"%s\", ino #%u, type %d, because curofs %ld < offset %ld\n",
140 fd
->name
, fd
->ino
, fd
->type
, curofs
, (unsigned long)ctx
->pos
);
144 jffs2_dbg(2, "Skipping deletion dirent \"%s\"\n",
149 jffs2_dbg(2, "Dirent %ld: \"%s\", ino #%u, type %d\n",
150 (unsigned long)ctx
->pos
, fd
->name
, fd
->ino
, fd
->type
);
151 if (!dir_emit(ctx
, fd
->name
, strlen(fd
->name
), fd
->ino
, fd
->type
))
155 mutex_unlock(&f
->sem
);
159 /***********************************************************************/
162 static int jffs2_create(struct inode
*dir_i
, struct dentry
*dentry
,
163 umode_t mode
, bool excl
)
165 struct jffs2_raw_inode
*ri
;
166 struct jffs2_inode_info
*f
, *dir_f
;
167 struct jffs2_sb_info
*c
;
171 ri
= jffs2_alloc_raw_inode();
175 c
= JFFS2_SB_INFO(dir_i
->i_sb
);
177 jffs2_dbg(1, "%s()\n", __func__
);
179 inode
= jffs2_new_inode(dir_i
, mode
, ri
);
182 jffs2_dbg(1, "jffs2_new_inode() failed\n");
183 jffs2_free_raw_inode(ri
);
184 return PTR_ERR(inode
);
187 inode
->i_op
= &jffs2_file_inode_operations
;
188 inode
->i_fop
= &jffs2_file_operations
;
189 inode
->i_mapping
->a_ops
= &jffs2_file_address_operations
;
190 inode
->i_mapping
->nrpages
= 0;
192 f
= JFFS2_INODE_INFO(inode
);
193 dir_f
= JFFS2_INODE_INFO(dir_i
);
195 /* jffs2_do_create() will want to lock it, _after_ reserving
196 space and taking c-alloc_sem. If we keep it locked here,
197 lockdep gets unhappy (although it's a false positive;
198 nothing else will be looking at this inode yet so there's
199 no chance of AB-BA deadlock involving its f->sem). */
200 mutex_unlock(&f
->sem
);
202 ret
= jffs2_do_create(c
, dir_f
, f
, ri
, &dentry
->d_name
);
206 dir_i
->i_mtime
= dir_i
->i_ctime
= ITIME(je32_to_cpu(ri
->ctime
));
208 jffs2_free_raw_inode(ri
);
210 jffs2_dbg(1, "%s(): Created ino #%lu with mode %o, nlink %d(%d). nrpages %ld\n",
211 __func__
, inode
->i_ino
, inode
->i_mode
, inode
->i_nlink
,
212 f
->inocache
->pino_nlink
, inode
->i_mapping
->nrpages
);
214 unlock_new_inode(inode
);
215 d_instantiate(dentry
, inode
);
220 jffs2_free_raw_inode(ri
);
224 /***********************************************************************/
227 static int jffs2_unlink(struct inode
*dir_i
, struct dentry
*dentry
)
229 struct jffs2_sb_info
*c
= JFFS2_SB_INFO(dir_i
->i_sb
);
230 struct jffs2_inode_info
*dir_f
= JFFS2_INODE_INFO(dir_i
);
231 struct jffs2_inode_info
*dead_f
= JFFS2_INODE_INFO(d_inode(dentry
));
233 uint32_t now
= get_seconds();
235 ret
= jffs2_do_unlink(c
, dir_f
, dentry
->d_name
.name
,
236 dentry
->d_name
.len
, dead_f
, now
);
237 if (dead_f
->inocache
)
238 set_nlink(d_inode(dentry
), dead_f
->inocache
->pino_nlink
);
240 dir_i
->i_mtime
= dir_i
->i_ctime
= ITIME(now
);
243 /***********************************************************************/
246 static int jffs2_link (struct dentry
*old_dentry
, struct inode
*dir_i
, struct dentry
*dentry
)
248 struct jffs2_sb_info
*c
= JFFS2_SB_INFO(old_dentry
->d_sb
);
249 struct jffs2_inode_info
*f
= JFFS2_INODE_INFO(d_inode(old_dentry
));
250 struct jffs2_inode_info
*dir_f
= JFFS2_INODE_INFO(dir_i
);
255 /* Don't let people make hard links to bad inodes. */
259 if (d_is_dir(old_dentry
))
262 /* XXX: This is ugly */
263 type
= (d_inode(old_dentry
)->i_mode
& S_IFMT
) >> 12;
264 if (!type
) type
= DT_REG
;
267 ret
= jffs2_do_link(c
, dir_f
, f
->inocache
->ino
, type
, dentry
->d_name
.name
, dentry
->d_name
.len
, now
);
271 set_nlink(d_inode(old_dentry
), ++f
->inocache
->pino_nlink
);
272 mutex_unlock(&f
->sem
);
273 d_instantiate(dentry
, d_inode(old_dentry
));
274 dir_i
->i_mtime
= dir_i
->i_ctime
= ITIME(now
);
275 ihold(d_inode(old_dentry
));
280 /***********************************************************************/
282 static int jffs2_symlink (struct inode
*dir_i
, struct dentry
*dentry
, const char *target
)
284 struct jffs2_inode_info
*f
, *dir_f
;
285 struct jffs2_sb_info
*c
;
287 struct jffs2_raw_inode
*ri
;
288 struct jffs2_raw_dirent
*rd
;
289 struct jffs2_full_dnode
*fn
;
290 struct jffs2_full_dirent
*fd
;
293 int ret
, targetlen
= strlen(target
);
295 /* FIXME: If you care. We'd need to use frags for the target
296 if it grows much more than this */
298 return -ENAMETOOLONG
;
300 ri
= jffs2_alloc_raw_inode();
305 c
= JFFS2_SB_INFO(dir_i
->i_sb
);
307 /* Try to reserve enough space for both node and dirent.
308 * Just the node will do for now, though
310 namelen
= dentry
->d_name
.len
;
311 ret
= jffs2_reserve_space(c
, sizeof(*ri
) + targetlen
, &alloclen
,
312 ALLOC_NORMAL
, JFFS2_SUMMARY_INODE_SIZE
);
315 jffs2_free_raw_inode(ri
);
319 inode
= jffs2_new_inode(dir_i
, S_IFLNK
| S_IRWXUGO
, ri
);
322 jffs2_free_raw_inode(ri
);
323 jffs2_complete_reservation(c
);
324 return PTR_ERR(inode
);
327 inode
->i_op
= &jffs2_symlink_inode_operations
;
329 f
= JFFS2_INODE_INFO(inode
);
331 inode
->i_size
= targetlen
;
332 ri
->isize
= ri
->dsize
= ri
->csize
= cpu_to_je32(inode
->i_size
);
333 ri
->totlen
= cpu_to_je32(sizeof(*ri
) + inode
->i_size
);
334 ri
->hdr_crc
= cpu_to_je32(crc32(0, ri
, sizeof(struct jffs2_unknown_node
)-4));
336 ri
->compr
= JFFS2_COMPR_NONE
;
337 ri
->data_crc
= cpu_to_je32(crc32(0, target
, targetlen
));
338 ri
->node_crc
= cpu_to_je32(crc32(0, ri
, sizeof(*ri
)-8));
340 fn
= jffs2_write_dnode(c
, f
, ri
, target
, targetlen
, ALLOC_NORMAL
);
342 jffs2_free_raw_inode(ri
);
345 /* Eeek. Wave bye bye */
346 mutex_unlock(&f
->sem
);
347 jffs2_complete_reservation(c
);
352 /* We use f->target field to store the target path. */
353 f
->target
= kmemdup(target
, targetlen
+ 1, GFP_KERNEL
);
355 pr_warn("Can't allocate %d bytes of memory\n", targetlen
+ 1);
356 mutex_unlock(&f
->sem
);
357 jffs2_complete_reservation(c
);
361 inode
->i_link
= f
->target
;
363 jffs2_dbg(1, "%s(): symlink's target '%s' cached\n",
364 __func__
, (char *)f
->target
);
366 /* No data here. Only a metadata node, which will be
367 obsoleted by the first data write
370 mutex_unlock(&f
->sem
);
372 jffs2_complete_reservation(c
);
374 ret
= jffs2_init_security(inode
, dir_i
, &dentry
->d_name
);
378 ret
= jffs2_init_acl_post(inode
);
382 ret
= jffs2_reserve_space(c
, sizeof(*rd
)+namelen
, &alloclen
,
383 ALLOC_NORMAL
, JFFS2_SUMMARY_DIRENT_SIZE(namelen
));
387 rd
= jffs2_alloc_raw_dirent();
389 /* Argh. Now we treat it like a normal delete */
390 jffs2_complete_reservation(c
);
395 dir_f
= JFFS2_INODE_INFO(dir_i
);
396 mutex_lock(&dir_f
->sem
);
398 rd
->magic
= cpu_to_je16(JFFS2_MAGIC_BITMASK
);
399 rd
->nodetype
= cpu_to_je16(JFFS2_NODETYPE_DIRENT
);
400 rd
->totlen
= cpu_to_je32(sizeof(*rd
) + namelen
);
401 rd
->hdr_crc
= cpu_to_je32(crc32(0, rd
, sizeof(struct jffs2_unknown_node
)-4));
403 rd
->pino
= cpu_to_je32(dir_i
->i_ino
);
404 rd
->version
= cpu_to_je32(++dir_f
->highest_version
);
405 rd
->ino
= cpu_to_je32(inode
->i_ino
);
406 rd
->mctime
= cpu_to_je32(get_seconds());
409 rd
->node_crc
= cpu_to_je32(crc32(0, rd
, sizeof(*rd
)-8));
410 rd
->name_crc
= cpu_to_je32(crc32(0, dentry
->d_name
.name
, namelen
));
412 fd
= jffs2_write_dirent(c
, dir_f
, rd
, dentry
->d_name
.name
, namelen
, ALLOC_NORMAL
);
415 /* dirent failed to write. Delete the inode normally
416 as if it were the final unlink() */
417 jffs2_complete_reservation(c
);
418 jffs2_free_raw_dirent(rd
);
419 mutex_unlock(&dir_f
->sem
);
424 dir_i
->i_mtime
= dir_i
->i_ctime
= ITIME(je32_to_cpu(rd
->mctime
));
426 jffs2_free_raw_dirent(rd
);
428 /* Link the fd into the inode's list, obsoleting an old
430 jffs2_add_fd_to_list(c
, fd
, &dir_f
->dents
);
432 mutex_unlock(&dir_f
->sem
);
433 jffs2_complete_reservation(c
);
435 unlock_new_inode(inode
);
436 d_instantiate(dentry
, inode
);
445 static int jffs2_mkdir (struct inode
*dir_i
, struct dentry
*dentry
, umode_t mode
)
447 struct jffs2_inode_info
*f
, *dir_f
;
448 struct jffs2_sb_info
*c
;
450 struct jffs2_raw_inode
*ri
;
451 struct jffs2_raw_dirent
*rd
;
452 struct jffs2_full_dnode
*fn
;
453 struct jffs2_full_dirent
*fd
;
460 ri
= jffs2_alloc_raw_inode();
464 c
= JFFS2_SB_INFO(dir_i
->i_sb
);
466 /* Try to reserve enough space for both node and dirent.
467 * Just the node will do for now, though
469 namelen
= dentry
->d_name
.len
;
470 ret
= jffs2_reserve_space(c
, sizeof(*ri
), &alloclen
, ALLOC_NORMAL
,
471 JFFS2_SUMMARY_INODE_SIZE
);
474 jffs2_free_raw_inode(ri
);
478 inode
= jffs2_new_inode(dir_i
, mode
, ri
);
481 jffs2_free_raw_inode(ri
);
482 jffs2_complete_reservation(c
);
483 return PTR_ERR(inode
);
486 inode
->i_op
= &jffs2_dir_inode_operations
;
487 inode
->i_fop
= &jffs2_dir_operations
;
489 f
= JFFS2_INODE_INFO(inode
);
491 /* Directories get nlink 2 at start */
493 /* but ic->pino_nlink is the parent ino# */
494 f
->inocache
->pino_nlink
= dir_i
->i_ino
;
496 ri
->data_crc
= cpu_to_je32(0);
497 ri
->node_crc
= cpu_to_je32(crc32(0, ri
, sizeof(*ri
)-8));
499 fn
= jffs2_write_dnode(c
, f
, ri
, NULL
, 0, ALLOC_NORMAL
);
501 jffs2_free_raw_inode(ri
);
504 /* Eeek. Wave bye bye */
505 mutex_unlock(&f
->sem
);
506 jffs2_complete_reservation(c
);
510 /* No data here. Only a metadata node, which will be
511 obsoleted by the first data write
514 mutex_unlock(&f
->sem
);
516 jffs2_complete_reservation(c
);
518 ret
= jffs2_init_security(inode
, dir_i
, &dentry
->d_name
);
522 ret
= jffs2_init_acl_post(inode
);
526 ret
= jffs2_reserve_space(c
, sizeof(*rd
)+namelen
, &alloclen
,
527 ALLOC_NORMAL
, JFFS2_SUMMARY_DIRENT_SIZE(namelen
));
531 rd
= jffs2_alloc_raw_dirent();
533 /* Argh. Now we treat it like a normal delete */
534 jffs2_complete_reservation(c
);
539 dir_f
= JFFS2_INODE_INFO(dir_i
);
540 mutex_lock(&dir_f
->sem
);
542 rd
->magic
= cpu_to_je16(JFFS2_MAGIC_BITMASK
);
543 rd
->nodetype
= cpu_to_je16(JFFS2_NODETYPE_DIRENT
);
544 rd
->totlen
= cpu_to_je32(sizeof(*rd
) + namelen
);
545 rd
->hdr_crc
= cpu_to_je32(crc32(0, rd
, sizeof(struct jffs2_unknown_node
)-4));
547 rd
->pino
= cpu_to_je32(dir_i
->i_ino
);
548 rd
->version
= cpu_to_je32(++dir_f
->highest_version
);
549 rd
->ino
= cpu_to_je32(inode
->i_ino
);
550 rd
->mctime
= cpu_to_je32(get_seconds());
553 rd
->node_crc
= cpu_to_je32(crc32(0, rd
, sizeof(*rd
)-8));
554 rd
->name_crc
= cpu_to_je32(crc32(0, dentry
->d_name
.name
, namelen
));
556 fd
= jffs2_write_dirent(c
, dir_f
, rd
, dentry
->d_name
.name
, namelen
, ALLOC_NORMAL
);
559 /* dirent failed to write. Delete the inode normally
560 as if it were the final unlink() */
561 jffs2_complete_reservation(c
);
562 jffs2_free_raw_dirent(rd
);
563 mutex_unlock(&dir_f
->sem
);
568 dir_i
->i_mtime
= dir_i
->i_ctime
= ITIME(je32_to_cpu(rd
->mctime
));
571 jffs2_free_raw_dirent(rd
);
573 /* Link the fd into the inode's list, obsoleting an old
575 jffs2_add_fd_to_list(c
, fd
, &dir_f
->dents
);
577 mutex_unlock(&dir_f
->sem
);
578 jffs2_complete_reservation(c
);
580 unlock_new_inode(inode
);
581 d_instantiate(dentry
, inode
);
589 static int jffs2_rmdir (struct inode
*dir_i
, struct dentry
*dentry
)
591 struct jffs2_sb_info
*c
= JFFS2_SB_INFO(dir_i
->i_sb
);
592 struct jffs2_inode_info
*dir_f
= JFFS2_INODE_INFO(dir_i
);
593 struct jffs2_inode_info
*f
= JFFS2_INODE_INFO(d_inode(dentry
));
594 struct jffs2_full_dirent
*fd
;
596 uint32_t now
= get_seconds();
598 for (fd
= f
->dents
; fd
; fd
= fd
->next
) {
603 ret
= jffs2_do_unlink(c
, dir_f
, dentry
->d_name
.name
,
604 dentry
->d_name
.len
, f
, now
);
606 dir_i
->i_mtime
= dir_i
->i_ctime
= ITIME(now
);
607 clear_nlink(d_inode(dentry
));
613 static int jffs2_mknod (struct inode
*dir_i
, struct dentry
*dentry
, umode_t mode
, dev_t rdev
)
615 struct jffs2_inode_info
*f
, *dir_f
;
616 struct jffs2_sb_info
*c
;
618 struct jffs2_raw_inode
*ri
;
619 struct jffs2_raw_dirent
*rd
;
620 struct jffs2_full_dnode
*fn
;
621 struct jffs2_full_dirent
*fd
;
623 union jffs2_device_node dev
;
628 ri
= jffs2_alloc_raw_inode();
632 c
= JFFS2_SB_INFO(dir_i
->i_sb
);
634 if (S_ISBLK(mode
) || S_ISCHR(mode
))
635 devlen
= jffs2_encode_dev(&dev
, rdev
);
637 /* Try to reserve enough space for both node and dirent.
638 * Just the node will do for now, though
640 namelen
= dentry
->d_name
.len
;
641 ret
= jffs2_reserve_space(c
, sizeof(*ri
) + devlen
, &alloclen
,
642 ALLOC_NORMAL
, JFFS2_SUMMARY_INODE_SIZE
);
645 jffs2_free_raw_inode(ri
);
649 inode
= jffs2_new_inode(dir_i
, mode
, ri
);
652 jffs2_free_raw_inode(ri
);
653 jffs2_complete_reservation(c
);
654 return PTR_ERR(inode
);
656 inode
->i_op
= &jffs2_file_inode_operations
;
657 init_special_inode(inode
, inode
->i_mode
, rdev
);
659 f
= JFFS2_INODE_INFO(inode
);
661 ri
->dsize
= ri
->csize
= cpu_to_je32(devlen
);
662 ri
->totlen
= cpu_to_je32(sizeof(*ri
) + devlen
);
663 ri
->hdr_crc
= cpu_to_je32(crc32(0, ri
, sizeof(struct jffs2_unknown_node
)-4));
665 ri
->compr
= JFFS2_COMPR_NONE
;
666 ri
->data_crc
= cpu_to_je32(crc32(0, &dev
, devlen
));
667 ri
->node_crc
= cpu_to_je32(crc32(0, ri
, sizeof(*ri
)-8));
669 fn
= jffs2_write_dnode(c
, f
, ri
, (char *)&dev
, devlen
, ALLOC_NORMAL
);
671 jffs2_free_raw_inode(ri
);
674 /* Eeek. Wave bye bye */
675 mutex_unlock(&f
->sem
);
676 jffs2_complete_reservation(c
);
680 /* No data here. Only a metadata node, which will be
681 obsoleted by the first data write
684 mutex_unlock(&f
->sem
);
686 jffs2_complete_reservation(c
);
688 ret
= jffs2_init_security(inode
, dir_i
, &dentry
->d_name
);
692 ret
= jffs2_init_acl_post(inode
);
696 ret
= jffs2_reserve_space(c
, sizeof(*rd
)+namelen
, &alloclen
,
697 ALLOC_NORMAL
, JFFS2_SUMMARY_DIRENT_SIZE(namelen
));
701 rd
= jffs2_alloc_raw_dirent();
703 /* Argh. Now we treat it like a normal delete */
704 jffs2_complete_reservation(c
);
709 dir_f
= JFFS2_INODE_INFO(dir_i
);
710 mutex_lock(&dir_f
->sem
);
712 rd
->magic
= cpu_to_je16(JFFS2_MAGIC_BITMASK
);
713 rd
->nodetype
= cpu_to_je16(JFFS2_NODETYPE_DIRENT
);
714 rd
->totlen
= cpu_to_je32(sizeof(*rd
) + namelen
);
715 rd
->hdr_crc
= cpu_to_je32(crc32(0, rd
, sizeof(struct jffs2_unknown_node
)-4));
717 rd
->pino
= cpu_to_je32(dir_i
->i_ino
);
718 rd
->version
= cpu_to_je32(++dir_f
->highest_version
);
719 rd
->ino
= cpu_to_je32(inode
->i_ino
);
720 rd
->mctime
= cpu_to_je32(get_seconds());
723 /* XXX: This is ugly. */
724 rd
->type
= (mode
& S_IFMT
) >> 12;
726 rd
->node_crc
= cpu_to_je32(crc32(0, rd
, sizeof(*rd
)-8));
727 rd
->name_crc
= cpu_to_je32(crc32(0, dentry
->d_name
.name
, namelen
));
729 fd
= jffs2_write_dirent(c
, dir_f
, rd
, dentry
->d_name
.name
, namelen
, ALLOC_NORMAL
);
732 /* dirent failed to write. Delete the inode normally
733 as if it were the final unlink() */
734 jffs2_complete_reservation(c
);
735 jffs2_free_raw_dirent(rd
);
736 mutex_unlock(&dir_f
->sem
);
741 dir_i
->i_mtime
= dir_i
->i_ctime
= ITIME(je32_to_cpu(rd
->mctime
));
743 jffs2_free_raw_dirent(rd
);
745 /* Link the fd into the inode's list, obsoleting an old
747 jffs2_add_fd_to_list(c
, fd
, &dir_f
->dents
);
749 mutex_unlock(&dir_f
->sem
);
750 jffs2_complete_reservation(c
);
752 unlock_new_inode(inode
);
753 d_instantiate(dentry
, inode
);
761 static int jffs2_rename (struct inode
*old_dir_i
, struct dentry
*old_dentry
,
762 struct inode
*new_dir_i
, struct dentry
*new_dentry
)
765 struct jffs2_sb_info
*c
= JFFS2_SB_INFO(old_dir_i
->i_sb
);
766 struct jffs2_inode_info
*victim_f
= NULL
;
770 /* The VFS will check for us and prevent trying to rename a
771 * file over a directory and vice versa, but if it's a directory,
772 * the VFS can't check whether the victim is empty. The filesystem
773 * needs to do that for itself.
775 if (d_really_is_positive(new_dentry
)) {
776 victim_f
= JFFS2_INODE_INFO(d_inode(new_dentry
));
777 if (d_is_dir(new_dentry
)) {
778 struct jffs2_full_dirent
*fd
;
780 mutex_lock(&victim_f
->sem
);
781 for (fd
= victim_f
->dents
; fd
; fd
= fd
->next
) {
783 mutex_unlock(&victim_f
->sem
);
787 mutex_unlock(&victim_f
->sem
);
791 /* XXX: We probably ought to alloc enough space for
792 both nodes at the same time. Writing the new link,
793 then getting -ENOSPC, is quite bad :)
796 /* Make a hard link */
798 /* XXX: This is ugly */
799 type
= (d_inode(old_dentry
)->i_mode
& S_IFMT
) >> 12;
800 if (!type
) type
= DT_REG
;
803 ret
= jffs2_do_link(c
, JFFS2_INODE_INFO(new_dir_i
),
804 d_inode(old_dentry
)->i_ino
, type
,
805 new_dentry
->d_name
.name
, new_dentry
->d_name
.len
, now
);
811 /* There was a victim. Kill it off nicely */
812 if (d_is_dir(new_dentry
))
813 clear_nlink(d_inode(new_dentry
));
815 drop_nlink(d_inode(new_dentry
));
816 /* Don't oops if the victim was a dirent pointing to an
817 inode which didn't exist. */
818 if (victim_f
->inocache
) {
819 mutex_lock(&victim_f
->sem
);
820 if (d_is_dir(new_dentry
))
821 victim_f
->inocache
->pino_nlink
= 0;
823 victim_f
->inocache
->pino_nlink
--;
824 mutex_unlock(&victim_f
->sem
);
828 /* If it was a directory we moved, and there was no victim,
829 increase i_nlink on its new parent */
830 if (d_is_dir(old_dentry
) && !victim_f
)
831 inc_nlink(new_dir_i
);
833 /* Unlink the original */
834 ret
= jffs2_do_unlink(c
, JFFS2_INODE_INFO(old_dir_i
),
835 old_dentry
->d_name
.name
, old_dentry
->d_name
.len
, NULL
, now
);
837 /* We don't touch inode->i_nlink */
840 /* Oh shit. We really ought to make a single node which can do both atomically */
841 struct jffs2_inode_info
*f
= JFFS2_INODE_INFO(d_inode(old_dentry
));
843 inc_nlink(d_inode(old_dentry
));
844 if (f
->inocache
&& !d_is_dir(old_dentry
))
845 f
->inocache
->pino_nlink
++;
846 mutex_unlock(&f
->sem
);
848 pr_notice("%s(): Link succeeded, unlink failed (err %d). You now have a hard link\n",
851 * We can't keep the target in dcache after that.
852 * For one thing, we can't afford dentry aliases for directories.
853 * For another, if there was a victim, we _can't_ set new inode
854 * for that sucker and we have to trigger mount eviction - the
855 * caller won't do it on its own since we are returning an error.
857 d_invalidate(new_dentry
);
858 new_dir_i
->i_mtime
= new_dir_i
->i_ctime
= ITIME(now
);
862 if (d_is_dir(old_dentry
))
863 drop_nlink(old_dir_i
);
865 new_dir_i
->i_mtime
= new_dir_i
->i_ctime
= old_dir_i
->i_mtime
= old_dir_i
->i_ctime
= ITIME(now
);