2 * JFFS2 -- Journalling Flash File System, Version 2.
4 * Copyright (C) 2001-2003 Red Hat, Inc.
6 * Created by David Woodhouse <dwmw2@infradead.org>
8 * For licensing information, see the file 'LICENCE' in this directory.
10 * $Id: dir.c,v 1.88 2005/08/17 13:46:22 dedekind Exp $
14 #include <linux/kernel.h>
15 #include <linux/slab.h>
16 #include <linux/sched.h>
18 #include <linux/crc32.h>
19 #include <linux/jffs2.h>
20 #include <linux/jffs2_fs_i.h>
21 #include <linux/jffs2_fs_sb.h>
22 #include <linux/time.h>
25 static int jffs2_readdir (struct file
*, void *, filldir_t
);
27 static int jffs2_create (struct inode
*,struct dentry
*,int,
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
*,int);
35 static int jffs2_rmdir (struct inode
*,struct dentry
*);
36 static int jffs2_mknod (struct inode
*,struct dentry
*,int,dev_t
);
37 static int jffs2_rename (struct inode
*, struct dentry
*,
38 struct inode
*, struct dentry
*);
40 struct file_operations jffs2_dir_operations
=
42 .read
= generic_read_dir
,
43 .readdir
= jffs2_readdir
,
49 struct inode_operations jffs2_dir_inode_operations
=
51 .create
= jffs2_create
,
52 .lookup
= jffs2_lookup
,
54 .unlink
= jffs2_unlink
,
55 .symlink
= jffs2_symlink
,
59 .rename
= jffs2_rename
,
60 .setattr
= jffs2_setattr
,
63 /***********************************************************************/
66 /* We keep the dirent list sorted in increasing order of name hash,
67 and we use the same hash function as the dentries. Makes this
70 static struct dentry
*jffs2_lookup(struct inode
*dir_i
, struct dentry
*target
,
73 struct jffs2_inode_info
*dir_f
;
74 struct jffs2_sb_info
*c
;
75 struct jffs2_full_dirent
*fd
= NULL
, *fd_list
;
77 struct inode
*inode
= NULL
;
79 D1(printk(KERN_DEBUG
"jffs2_lookup()\n"));
81 dir_f
= JFFS2_INODE_INFO(dir_i
);
82 c
= JFFS2_SB_INFO(dir_i
->i_sb
);
86 /* NB: The 2.2 backport will need to explicitly check for '.' and '..' here */
87 for (fd_list
= dir_f
->dents
; fd_list
&& fd_list
->nhash
<= target
->d_name
.hash
; fd_list
= fd_list
->next
) {
88 if (fd_list
->nhash
== target
->d_name
.hash
&&
89 (!fd
|| fd_list
->version
> fd
->version
) &&
90 strlen(fd_list
->name
) == target
->d_name
.len
&&
91 !strncmp(fd_list
->name
, target
->d_name
.name
, target
->d_name
.len
)) {
99 inode
= iget(dir_i
->i_sb
, ino
);
101 printk(KERN_WARNING
"iget() failed for ino #%u\n", ino
);
102 return (ERR_PTR(-EIO
));
106 d_add(target
, inode
);
111 /***********************************************************************/
114 static int jffs2_readdir(struct file
*filp
, void *dirent
, filldir_t filldir
)
116 struct jffs2_inode_info
*f
;
117 struct jffs2_sb_info
*c
;
118 struct inode
*inode
= filp
->f_dentry
->d_inode
;
119 struct jffs2_full_dirent
*fd
;
120 unsigned long offset
, curofs
;
122 D1(printk(KERN_DEBUG
"jffs2_readdir() for dir_i #%lu\n", filp
->f_dentry
->d_inode
->i_ino
));
124 f
= JFFS2_INODE_INFO(inode
);
125 c
= JFFS2_SB_INFO(inode
->i_sb
);
127 offset
= filp
->f_pos
;
130 D1(printk(KERN_DEBUG
"Dirent 0: \".\", ino #%lu\n", inode
->i_ino
));
131 if (filldir(dirent
, ".", 1, 0, inode
->i_ino
, DT_DIR
) < 0)
136 unsigned long pino
= parent_ino(filp
->f_dentry
);
137 D1(printk(KERN_DEBUG
"Dirent 1: \"..\", ino #%lu\n", pino
));
138 if (filldir(dirent
, "..", 2, 1, pino
, DT_DIR
) < 0)
145 for (fd
= f
->dents
; fd
; fd
= fd
->next
) {
148 /* First loop: curofs = 2; offset = 2 */
149 if (curofs
< offset
) {
150 D2(printk(KERN_DEBUG
"Skipping dirent: \"%s\", ino #%u, type %d, because curofs %ld < offset %ld\n",
151 fd
->name
, fd
->ino
, fd
->type
, curofs
, offset
));
155 D2(printk(KERN_DEBUG
"Skipping deletion dirent \"%s\"\n", fd
->name
));
159 D2(printk(KERN_DEBUG
"Dirent %ld: \"%s\", ino #%u, type %d\n", offset
, fd
->name
, fd
->ino
, fd
->type
));
160 if (filldir(dirent
, fd
->name
, strlen(fd
->name
), offset
, fd
->ino
, fd
->type
) < 0)
166 filp
->f_pos
= offset
;
170 /***********************************************************************/
173 static int jffs2_create(struct inode
*dir_i
, struct dentry
*dentry
, int mode
,
174 struct nameidata
*nd
)
176 struct jffs2_raw_inode
*ri
;
177 struct jffs2_inode_info
*f
, *dir_f
;
178 struct jffs2_sb_info
*c
;
182 ri
= jffs2_alloc_raw_inode();
186 c
= JFFS2_SB_INFO(dir_i
->i_sb
);
188 D1(printk(KERN_DEBUG
"jffs2_create()\n"));
190 inode
= jffs2_new_inode(dir_i
, mode
, ri
);
193 D1(printk(KERN_DEBUG
"jffs2_new_inode() failed\n"));
194 jffs2_free_raw_inode(ri
);
195 return PTR_ERR(inode
);
198 inode
->i_op
= &jffs2_file_inode_operations
;
199 inode
->i_fop
= &jffs2_file_operations
;
200 inode
->i_mapping
->a_ops
= &jffs2_file_address_operations
;
201 inode
->i_mapping
->nrpages
= 0;
203 f
= JFFS2_INODE_INFO(inode
);
204 dir_f
= JFFS2_INODE_INFO(dir_i
);
206 ret
= jffs2_do_create(c
, dir_f
, f
, ri
,
207 dentry
->d_name
.name
, dentry
->d_name
.len
);
210 make_bad_inode(inode
);
212 jffs2_free_raw_inode(ri
);
216 dir_i
->i_mtime
= dir_i
->i_ctime
= ITIME(je32_to_cpu(ri
->ctime
));
218 jffs2_free_raw_inode(ri
);
219 d_instantiate(dentry
, inode
);
221 D1(printk(KERN_DEBUG
"jffs2_create: Created ino #%lu with mode %o, nlink %d(%d). nrpages %ld\n",
222 inode
->i_ino
, inode
->i_mode
, inode
->i_nlink
, f
->inocache
->nlink
, inode
->i_mapping
->nrpages
));
226 /***********************************************************************/
229 static int jffs2_unlink(struct inode
*dir_i
, struct dentry
*dentry
)
231 struct jffs2_sb_info
*c
= JFFS2_SB_INFO(dir_i
->i_sb
);
232 struct jffs2_inode_info
*dir_f
= JFFS2_INODE_INFO(dir_i
);
233 struct jffs2_inode_info
*dead_f
= JFFS2_INODE_INFO(dentry
->d_inode
);
235 uint32_t now
= get_seconds();
237 ret
= jffs2_do_unlink(c
, dir_f
, dentry
->d_name
.name
,
238 dentry
->d_name
.len
, dead_f
, now
);
239 if (dead_f
->inocache
)
240 dentry
->d_inode
->i_nlink
= dead_f
->inocache
->nlink
;
242 dir_i
->i_mtime
= dir_i
->i_ctime
= ITIME(now
);
245 /***********************************************************************/
248 static int jffs2_link (struct dentry
*old_dentry
, struct inode
*dir_i
, struct dentry
*dentry
)
250 struct jffs2_sb_info
*c
= JFFS2_SB_INFO(old_dentry
->d_inode
->i_sb
);
251 struct jffs2_inode_info
*f
= JFFS2_INODE_INFO(old_dentry
->d_inode
);
252 struct jffs2_inode_info
*dir_f
= JFFS2_INODE_INFO(dir_i
);
257 /* Don't let people make hard links to bad inodes. */
261 if (S_ISDIR(old_dentry
->d_inode
->i_mode
))
264 /* XXX: This is ugly */
265 type
= (old_dentry
->d_inode
->i_mode
& S_IFMT
) >> 12;
266 if (!type
) type
= DT_REG
;
269 ret
= jffs2_do_link(c
, dir_f
, f
->inocache
->ino
, type
, dentry
->d_name
.name
, dentry
->d_name
.len
, now
);
273 old_dentry
->d_inode
->i_nlink
= ++f
->inocache
->nlink
;
275 d_instantiate(dentry
, old_dentry
->d_inode
);
276 dir_i
->i_mtime
= dir_i
->i_ctime
= ITIME(now
);
277 atomic_inc(&old_dentry
->d_inode
->i_count
);
282 /***********************************************************************/
284 static int jffs2_symlink (struct inode
*dir_i
, struct dentry
*dentry
, const char *target
)
286 struct jffs2_inode_info
*f
, *dir_f
;
287 struct jffs2_sb_info
*c
;
289 struct jffs2_raw_inode
*ri
;
290 struct jffs2_raw_dirent
*rd
;
291 struct jffs2_full_dnode
*fn
;
292 struct jffs2_full_dirent
*fd
;
294 uint32_t alloclen
, phys_ofs
;
295 int ret
, targetlen
= strlen(target
);
297 /* FIXME: If you care. We'd need to use frags for the target
298 if it grows much more than this */
302 ri
= jffs2_alloc_raw_inode();
307 c
= JFFS2_SB_INFO(dir_i
->i_sb
);
309 /* Try to reserve enough space for both node and dirent.
310 * Just the node will do for now, though
312 namelen
= dentry
->d_name
.len
;
313 ret
= jffs2_reserve_space(c
, sizeof(*ri
) + targetlen
, &phys_ofs
, &alloclen
, ALLOC_NORMAL
);
316 jffs2_free_raw_inode(ri
);
320 inode
= jffs2_new_inode(dir_i
, S_IFLNK
| S_IRWXUGO
, ri
);
323 jffs2_free_raw_inode(ri
);
324 jffs2_complete_reservation(c
);
325 return PTR_ERR(inode
);
328 inode
->i_op
= &jffs2_symlink_inode_operations
;
330 f
= JFFS2_INODE_INFO(inode
);
332 inode
->i_size
= targetlen
;
333 ri
->isize
= ri
->dsize
= ri
->csize
= cpu_to_je32(inode
->i_size
);
334 ri
->totlen
= cpu_to_je32(sizeof(*ri
) + inode
->i_size
);
335 ri
->hdr_crc
= cpu_to_je32(crc32(0, ri
, sizeof(struct jffs2_unknown_node
)-4));
337 ri
->compr
= JFFS2_COMPR_NONE
;
338 ri
->data_crc
= cpu_to_je32(crc32(0, target
, targetlen
));
339 ri
->node_crc
= cpu_to_je32(crc32(0, ri
, sizeof(*ri
)-8));
341 fn
= jffs2_write_dnode(c
, f
, ri
, target
, targetlen
, phys_ofs
, ALLOC_NORMAL
);
343 jffs2_free_raw_inode(ri
);
346 /* Eeek. Wave bye bye */
348 jffs2_complete_reservation(c
);
349 jffs2_clear_inode(inode
);
353 /* We use f->target field to store the target path. */
354 f
->target
= kmalloc(targetlen
+ 1, GFP_KERNEL
);
356 printk(KERN_WARNING
"Can't allocate %d bytes of memory\n", targetlen
+ 1);
358 jffs2_complete_reservation(c
);
359 jffs2_clear_inode(inode
);
363 memcpy(f
->target
, target
, targetlen
+ 1);
364 D1(printk(KERN_DEBUG
"jffs2_symlink: symlink's target '%s' cached\n", (char *)f
->target
));
366 /* No data here. Only a metadata node, which will be
367 obsoleted by the first data write
372 jffs2_complete_reservation(c
);
373 ret
= jffs2_reserve_space(c
, sizeof(*rd
)+namelen
, &phys_ofs
, &alloclen
, ALLOC_NORMAL
);
376 jffs2_clear_inode(inode
);
380 rd
= jffs2_alloc_raw_dirent();
382 /* Argh. Now we treat it like a normal delete */
383 jffs2_complete_reservation(c
);
384 jffs2_clear_inode(inode
);
388 dir_f
= JFFS2_INODE_INFO(dir_i
);
391 rd
->magic
= cpu_to_je16(JFFS2_MAGIC_BITMASK
);
392 rd
->nodetype
= cpu_to_je16(JFFS2_NODETYPE_DIRENT
);
393 rd
->totlen
= cpu_to_je32(sizeof(*rd
) + namelen
);
394 rd
->hdr_crc
= cpu_to_je32(crc32(0, rd
, sizeof(struct jffs2_unknown_node
)-4));
396 rd
->pino
= cpu_to_je32(dir_i
->i_ino
);
397 rd
->version
= cpu_to_je32(++dir_f
->highest_version
);
398 rd
->ino
= cpu_to_je32(inode
->i_ino
);
399 rd
->mctime
= cpu_to_je32(get_seconds());
402 rd
->node_crc
= cpu_to_je32(crc32(0, rd
, sizeof(*rd
)-8));
403 rd
->name_crc
= cpu_to_je32(crc32(0, dentry
->d_name
.name
, namelen
));
405 fd
= jffs2_write_dirent(c
, dir_f
, rd
, dentry
->d_name
.name
, namelen
, phys_ofs
, ALLOC_NORMAL
);
408 /* dirent failed to write. Delete the inode normally
409 as if it were the final unlink() */
410 jffs2_complete_reservation(c
);
411 jffs2_free_raw_dirent(rd
);
413 jffs2_clear_inode(inode
);
417 dir_i
->i_mtime
= dir_i
->i_ctime
= ITIME(je32_to_cpu(rd
->mctime
));
419 jffs2_free_raw_dirent(rd
);
421 /* Link the fd into the inode's list, obsoleting an old
423 jffs2_add_fd_to_list(c
, fd
, &dir_f
->dents
);
426 jffs2_complete_reservation(c
);
428 d_instantiate(dentry
, inode
);
433 static int jffs2_mkdir (struct inode
*dir_i
, struct dentry
*dentry
, int mode
)
435 struct jffs2_inode_info
*f
, *dir_f
;
436 struct jffs2_sb_info
*c
;
438 struct jffs2_raw_inode
*ri
;
439 struct jffs2_raw_dirent
*rd
;
440 struct jffs2_full_dnode
*fn
;
441 struct jffs2_full_dirent
*fd
;
443 uint32_t alloclen
, phys_ofs
;
448 ri
= jffs2_alloc_raw_inode();
452 c
= JFFS2_SB_INFO(dir_i
->i_sb
);
454 /* Try to reserve enough space for both node and dirent.
455 * Just the node will do for now, though
457 namelen
= dentry
->d_name
.len
;
458 ret
= jffs2_reserve_space(c
, sizeof(*ri
), &phys_ofs
, &alloclen
, ALLOC_NORMAL
);
461 jffs2_free_raw_inode(ri
);
465 inode
= jffs2_new_inode(dir_i
, mode
, ri
);
468 jffs2_free_raw_inode(ri
);
469 jffs2_complete_reservation(c
);
470 return PTR_ERR(inode
);
473 inode
->i_op
= &jffs2_dir_inode_operations
;
474 inode
->i_fop
= &jffs2_dir_operations
;
475 /* Directories get nlink 2 at start */
478 f
= JFFS2_INODE_INFO(inode
);
480 ri
->data_crc
= cpu_to_je32(0);
481 ri
->node_crc
= cpu_to_je32(crc32(0, ri
, sizeof(*ri
)-8));
483 fn
= jffs2_write_dnode(c
, f
, ri
, NULL
, 0, phys_ofs
, ALLOC_NORMAL
);
485 jffs2_free_raw_inode(ri
);
488 /* Eeek. Wave bye bye */
490 jffs2_complete_reservation(c
);
491 jffs2_clear_inode(inode
);
494 /* No data here. Only a metadata node, which will be
495 obsoleted by the first data write
500 jffs2_complete_reservation(c
);
501 ret
= jffs2_reserve_space(c
, sizeof(*rd
)+namelen
, &phys_ofs
, &alloclen
, ALLOC_NORMAL
);
504 jffs2_clear_inode(inode
);
508 rd
= jffs2_alloc_raw_dirent();
510 /* Argh. Now we treat it like a normal delete */
511 jffs2_complete_reservation(c
);
512 jffs2_clear_inode(inode
);
516 dir_f
= JFFS2_INODE_INFO(dir_i
);
519 rd
->magic
= cpu_to_je16(JFFS2_MAGIC_BITMASK
);
520 rd
->nodetype
= cpu_to_je16(JFFS2_NODETYPE_DIRENT
);
521 rd
->totlen
= cpu_to_je32(sizeof(*rd
) + namelen
);
522 rd
->hdr_crc
= cpu_to_je32(crc32(0, rd
, sizeof(struct jffs2_unknown_node
)-4));
524 rd
->pino
= cpu_to_je32(dir_i
->i_ino
);
525 rd
->version
= cpu_to_je32(++dir_f
->highest_version
);
526 rd
->ino
= cpu_to_je32(inode
->i_ino
);
527 rd
->mctime
= cpu_to_je32(get_seconds());
530 rd
->node_crc
= cpu_to_je32(crc32(0, rd
, sizeof(*rd
)-8));
531 rd
->name_crc
= cpu_to_je32(crc32(0, dentry
->d_name
.name
, namelen
));
533 fd
= jffs2_write_dirent(c
, dir_f
, rd
, dentry
->d_name
.name
, namelen
, phys_ofs
, ALLOC_NORMAL
);
536 /* dirent failed to write. Delete the inode normally
537 as if it were the final unlink() */
538 jffs2_complete_reservation(c
);
539 jffs2_free_raw_dirent(rd
);
541 jffs2_clear_inode(inode
);
545 dir_i
->i_mtime
= dir_i
->i_ctime
= ITIME(je32_to_cpu(rd
->mctime
));
548 jffs2_free_raw_dirent(rd
);
550 /* Link the fd into the inode's list, obsoleting an old
552 jffs2_add_fd_to_list(c
, fd
, &dir_f
->dents
);
555 jffs2_complete_reservation(c
);
557 d_instantiate(dentry
, inode
);
561 static int jffs2_rmdir (struct inode
*dir_i
, struct dentry
*dentry
)
563 struct jffs2_inode_info
*f
= JFFS2_INODE_INFO(dentry
->d_inode
);
564 struct jffs2_full_dirent
*fd
;
567 for (fd
= f
->dents
; fd
; fd
= fd
->next
) {
571 ret
= jffs2_unlink(dir_i
, dentry
);
577 static int jffs2_mknod (struct inode
*dir_i
, struct dentry
*dentry
, int mode
, dev_t rdev
)
579 struct jffs2_inode_info
*f
, *dir_f
;
580 struct jffs2_sb_info
*c
;
582 struct jffs2_raw_inode
*ri
;
583 struct jffs2_raw_dirent
*rd
;
584 struct jffs2_full_dnode
*fn
;
585 struct jffs2_full_dirent
*fd
;
589 uint32_t alloclen
, phys_ofs
;
592 if (!old_valid_dev(rdev
))
595 ri
= jffs2_alloc_raw_inode();
599 c
= JFFS2_SB_INFO(dir_i
->i_sb
);
601 if (S_ISBLK(mode
) || S_ISCHR(mode
)) {
602 dev
= cpu_to_je16(old_encode_dev(rdev
));
603 devlen
= sizeof(dev
);
606 /* Try to reserve enough space for both node and dirent.
607 * Just the node will do for now, though
609 namelen
= dentry
->d_name
.len
;
610 ret
= jffs2_reserve_space(c
, sizeof(*ri
) + devlen
, &phys_ofs
, &alloclen
, ALLOC_NORMAL
);
613 jffs2_free_raw_inode(ri
);
617 inode
= jffs2_new_inode(dir_i
, mode
, ri
);
620 jffs2_free_raw_inode(ri
);
621 jffs2_complete_reservation(c
);
622 return PTR_ERR(inode
);
624 inode
->i_op
= &jffs2_file_inode_operations
;
625 init_special_inode(inode
, inode
->i_mode
, rdev
);
627 f
= JFFS2_INODE_INFO(inode
);
629 ri
->dsize
= ri
->csize
= cpu_to_je32(devlen
);
630 ri
->totlen
= cpu_to_je32(sizeof(*ri
) + devlen
);
631 ri
->hdr_crc
= cpu_to_je32(crc32(0, ri
, sizeof(struct jffs2_unknown_node
)-4));
633 ri
->compr
= JFFS2_COMPR_NONE
;
634 ri
->data_crc
= cpu_to_je32(crc32(0, &dev
, devlen
));
635 ri
->node_crc
= cpu_to_je32(crc32(0, ri
, sizeof(*ri
)-8));
637 fn
= jffs2_write_dnode(c
, f
, ri
, (char *)&dev
, devlen
, phys_ofs
, ALLOC_NORMAL
);
639 jffs2_free_raw_inode(ri
);
642 /* Eeek. Wave bye bye */
644 jffs2_complete_reservation(c
);
645 jffs2_clear_inode(inode
);
648 /* No data here. Only a metadata node, which will be
649 obsoleted by the first data write
654 jffs2_complete_reservation(c
);
655 ret
= jffs2_reserve_space(c
, sizeof(*rd
)+namelen
, &phys_ofs
, &alloclen
, ALLOC_NORMAL
);
658 jffs2_clear_inode(inode
);
662 rd
= jffs2_alloc_raw_dirent();
664 /* Argh. Now we treat it like a normal delete */
665 jffs2_complete_reservation(c
);
666 jffs2_clear_inode(inode
);
670 dir_f
= JFFS2_INODE_INFO(dir_i
);
673 rd
->magic
= cpu_to_je16(JFFS2_MAGIC_BITMASK
);
674 rd
->nodetype
= cpu_to_je16(JFFS2_NODETYPE_DIRENT
);
675 rd
->totlen
= cpu_to_je32(sizeof(*rd
) + namelen
);
676 rd
->hdr_crc
= cpu_to_je32(crc32(0, rd
, sizeof(struct jffs2_unknown_node
)-4));
678 rd
->pino
= cpu_to_je32(dir_i
->i_ino
);
679 rd
->version
= cpu_to_je32(++dir_f
->highest_version
);
680 rd
->ino
= cpu_to_je32(inode
->i_ino
);
681 rd
->mctime
= cpu_to_je32(get_seconds());
684 /* XXX: This is ugly. */
685 rd
->type
= (mode
& S_IFMT
) >> 12;
687 rd
->node_crc
= cpu_to_je32(crc32(0, rd
, sizeof(*rd
)-8));
688 rd
->name_crc
= cpu_to_je32(crc32(0, dentry
->d_name
.name
, namelen
));
690 fd
= jffs2_write_dirent(c
, dir_f
, rd
, dentry
->d_name
.name
, namelen
, phys_ofs
, ALLOC_NORMAL
);
693 /* dirent failed to write. Delete the inode normally
694 as if it were the final unlink() */
695 jffs2_complete_reservation(c
);
696 jffs2_free_raw_dirent(rd
);
698 jffs2_clear_inode(inode
);
702 dir_i
->i_mtime
= dir_i
->i_ctime
= ITIME(je32_to_cpu(rd
->mctime
));
704 jffs2_free_raw_dirent(rd
);
706 /* Link the fd into the inode's list, obsoleting an old
708 jffs2_add_fd_to_list(c
, fd
, &dir_f
->dents
);
711 jffs2_complete_reservation(c
);
713 d_instantiate(dentry
, inode
);
718 static int jffs2_rename (struct inode
*old_dir_i
, struct dentry
*old_dentry
,
719 struct inode
*new_dir_i
, struct dentry
*new_dentry
)
722 struct jffs2_sb_info
*c
= JFFS2_SB_INFO(old_dir_i
->i_sb
);
723 struct jffs2_inode_info
*victim_f
= NULL
;
727 /* The VFS will check for us and prevent trying to rename a
728 * file over a directory and vice versa, but if it's a directory,
729 * the VFS can't check whether the victim is empty. The filesystem
730 * needs to do that for itself.
732 if (new_dentry
->d_inode
) {
733 victim_f
= JFFS2_INODE_INFO(new_dentry
->d_inode
);
734 if (S_ISDIR(new_dentry
->d_inode
->i_mode
)) {
735 struct jffs2_full_dirent
*fd
;
737 down(&victim_f
->sem
);
738 for (fd
= victim_f
->dents
; fd
; fd
= fd
->next
) {
748 /* XXX: We probably ought to alloc enough space for
749 both nodes at the same time. Writing the new link,
750 then getting -ENOSPC, is quite bad :)
753 /* Make a hard link */
755 /* XXX: This is ugly */
756 type
= (old_dentry
->d_inode
->i_mode
& S_IFMT
) >> 12;
757 if (!type
) type
= DT_REG
;
760 ret
= jffs2_do_link(c
, JFFS2_INODE_INFO(new_dir_i
),
761 old_dentry
->d_inode
->i_ino
, type
,
762 new_dentry
->d_name
.name
, new_dentry
->d_name
.len
, now
);
768 /* There was a victim. Kill it off nicely */
769 new_dentry
->d_inode
->i_nlink
--;
770 /* Don't oops if the victim was a dirent pointing to an
771 inode which didn't exist. */
772 if (victim_f
->inocache
) {
773 down(&victim_f
->sem
);
774 victim_f
->inocache
->nlink
--;
779 /* If it was a directory we moved, and there was no victim,
780 increase i_nlink on its new parent */
781 if (S_ISDIR(old_dentry
->d_inode
->i_mode
) && !victim_f
)
782 new_dir_i
->i_nlink
++;
784 /* Unlink the original */
785 ret
= jffs2_do_unlink(c
, JFFS2_INODE_INFO(old_dir_i
),
786 old_dentry
->d_name
.name
, old_dentry
->d_name
.len
, NULL
, now
);
788 /* We don't touch inode->i_nlink */
791 /* Oh shit. We really ought to make a single node which can do both atomically */
792 struct jffs2_inode_info
*f
= JFFS2_INODE_INFO(old_dentry
->d_inode
);
794 old_dentry
->d_inode
->i_nlink
++;
796 f
->inocache
->nlink
++;
799 printk(KERN_NOTICE
"jffs2_rename(): Link succeeded, unlink failed (err %d). You now have a hard link\n", ret
);
800 /* Might as well let the VFS know */
801 d_instantiate(new_dentry
, old_dentry
->d_inode
);
802 atomic_inc(&old_dentry
->d_inode
->i_count
);
803 new_dir_i
->i_mtime
= new_dir_i
->i_ctime
= ITIME(now
);
807 if (S_ISDIR(old_dentry
->d_inode
->i_mode
))
808 old_dir_i
->i_nlink
--;
810 new_dir_i
->i_mtime
= new_dir_i
->i_ctime
= old_dir_i
->i_mtime
= old_dir_i
->i_ctime
= ITIME(now
);