2 * linux/fs/hpfs/namei.c
4 * Mikulas Patocka (mikulas@artax.karlin.mff.cuni.cz), 1998-1999
6 * adding & removing files & directories
8 #include <linux/sched.h>
11 static int hpfs_mkdir(struct inode
*dir
, struct dentry
*dentry
, int mode
)
13 const char *name
= dentry
->d_name
.name
;
14 unsigned len
= dentry
->d_name
.len
;
15 struct quad_buffer_head qbh0
;
16 struct buffer_head
*bh
;
17 struct hpfs_dirent
*de
;
24 struct hpfs_dirent dee
;
26 if ((err
= hpfs_chk_name((char *)name
, &len
))) return err
==-ENOENT
? -EINVAL
: err
;
29 fnode
= hpfs_alloc_fnode(dir
->i_sb
, hpfs_i(dir
)->i_dno
, &fno
, &bh
);
32 dnode
= hpfs_alloc_dnode(dir
->i_sb
, fno
, &dno
, &qbh0
, 1);
35 memset(&dee
, 0, sizeof dee
);
37 if (!(mode
& 0222)) dee
.read_only
= 1;
39 dee
.hidden
= name
[0] == '.';
41 dee
.creation_date
= dee
.write_date
= dee
.read_date
= gmt_to_local(dir
->i_sb
, get_seconds());
42 result
= new_inode(dir
->i_sb
);
45 hpfs_init_inode(result
);
47 hpfs_i(result
)->i_parent_dir
= dir
->i_ino
;
48 hpfs_i(result
)->i_dno
= dno
;
49 result
->i_ctime
.tv_sec
= result
->i_mtime
.tv_sec
= result
->i_atime
.tv_sec
= local_to_gmt(dir
->i_sb
, dee
.creation_date
);
50 result
->i_ctime
.tv_nsec
= 0;
51 result
->i_mtime
.tv_nsec
= 0;
52 result
->i_atime
.tv_nsec
= 0;
53 hpfs_i(result
)->i_ea_size
= 0;
54 result
->i_mode
|= S_IFDIR
;
55 result
->i_op
= &hpfs_dir_iops
;
56 result
->i_fop
= &hpfs_dir_ops
;
58 result
->i_size
= 2048;
61 result
->i_mode
&= ~0222;
63 mutex_lock(&hpfs_i(dir
)->i_mutex
);
64 r
= hpfs_add_dirent(dir
, (char *)name
, len
, &dee
, 0);
72 memcpy(fnode
->name
, name
, len
> 15 ? 15 : len
);
73 fnode
->up
= dir
->i_ino
;
75 fnode
->btree
.n_free_nodes
= 7;
76 fnode
->btree
.n_used_nodes
= 1;
77 fnode
->btree
.first_free
= 0x14;
78 fnode
->u
.external
[0].disk_secno
= dno
;
79 fnode
->u
.external
[0].file_secno
= -1;
80 dnode
->root_dnode
= 1;
82 de
= hpfs_add_de(dir
->i_sb
, dnode
, "\001\001", 2, 0);
83 de
->creation_date
= de
->write_date
= de
->read_date
= gmt_to_local(dir
->i_sb
, get_seconds());
84 if (!(mode
& 0222)) de
->read_only
= 1;
85 de
->first
= de
->directory
= 1;
86 /*de->hidden = de->system = 0;*/
88 mark_buffer_dirty(bh
);
90 hpfs_mark_4buffers_dirty(&qbh0
);
93 insert_inode_hash(result
);
95 if (result
->i_uid
!= current
->fsuid
||
96 result
->i_gid
!= current
->fsgid
||
97 result
->i_mode
!= (mode
| S_IFDIR
)) {
98 result
->i_uid
= current
->fsuid
;
99 result
->i_gid
= current
->fsgid
;
100 result
->i_mode
= mode
| S_IFDIR
;
101 hpfs_write_inode_nolock(result
);
103 d_instantiate(dentry
, result
);
104 mutex_unlock(&hpfs_i(dir
)->i_mutex
);
108 mutex_unlock(&hpfs_i(dir
)->i_mutex
);
112 hpfs_free_dnode(dir
->i_sb
, dno
);
115 hpfs_free_sectors(dir
->i_sb
, fno
, 1);
121 static int hpfs_create(struct inode
*dir
, struct dentry
*dentry
, int mode
, struct nameidata
*nd
)
123 const char *name
= dentry
->d_name
.name
;
124 unsigned len
= dentry
->d_name
.len
;
125 struct inode
*result
= NULL
;
126 struct buffer_head
*bh
;
130 struct hpfs_dirent dee
;
132 if ((err
= hpfs_chk_name((char *)name
, &len
)))
133 return err
==-ENOENT
? -EINVAL
: err
;
136 fnode
= hpfs_alloc_fnode(dir
->i_sb
, hpfs_i(dir
)->i_dno
, &fno
, &bh
);
139 memset(&dee
, 0, sizeof dee
);
140 if (!(mode
& 0222)) dee
.read_only
= 1;
142 dee
.hidden
= name
[0] == '.';
144 dee
.creation_date
= dee
.write_date
= dee
.read_date
= gmt_to_local(dir
->i_sb
, get_seconds());
146 result
= new_inode(dir
->i_sb
);
150 hpfs_init_inode(result
);
152 result
->i_mode
|= S_IFREG
;
153 result
->i_mode
&= ~0111;
154 result
->i_op
= &hpfs_file_iops
;
155 result
->i_fop
= &hpfs_file_ops
;
157 hpfs_decide_conv(result
, (char *)name
, len
);
158 hpfs_i(result
)->i_parent_dir
= dir
->i_ino
;
159 result
->i_ctime
.tv_sec
= result
->i_mtime
.tv_sec
= result
->i_atime
.tv_sec
= local_to_gmt(dir
->i_sb
, dee
.creation_date
);
160 result
->i_ctime
.tv_nsec
= 0;
161 result
->i_mtime
.tv_nsec
= 0;
162 result
->i_atime
.tv_nsec
= 0;
163 hpfs_i(result
)->i_ea_size
= 0;
165 result
->i_mode
&= ~0222;
166 result
->i_blocks
= 1;
168 result
->i_data
.a_ops
= &hpfs_aops
;
169 hpfs_i(result
)->mmu_private
= 0;
171 mutex_lock(&hpfs_i(dir
)->i_mutex
);
172 r
= hpfs_add_dirent(dir
, (char *)name
, len
, &dee
, 0);
180 memcpy(fnode
->name
, name
, len
> 15 ? 15 : len
);
181 fnode
->up
= dir
->i_ino
;
182 mark_buffer_dirty(bh
);
185 insert_inode_hash(result
);
187 if (result
->i_uid
!= current
->fsuid
||
188 result
->i_gid
!= current
->fsgid
||
189 result
->i_mode
!= (mode
| S_IFREG
)) {
190 result
->i_uid
= current
->fsuid
;
191 result
->i_gid
= current
->fsgid
;
192 result
->i_mode
= mode
| S_IFREG
;
193 hpfs_write_inode_nolock(result
);
195 d_instantiate(dentry
, result
);
196 mutex_unlock(&hpfs_i(dir
)->i_mutex
);
201 mutex_unlock(&hpfs_i(dir
)->i_mutex
);
205 hpfs_free_sectors(dir
->i_sb
, fno
, 1);
211 static int hpfs_mknod(struct inode
*dir
, struct dentry
*dentry
, int mode
, dev_t rdev
)
213 const char *name
= dentry
->d_name
.name
;
214 unsigned len
= dentry
->d_name
.len
;
215 struct buffer_head
*bh
;
219 struct hpfs_dirent dee
;
220 struct inode
*result
= NULL
;
222 if ((err
= hpfs_chk_name((char *)name
, &len
))) return err
==-ENOENT
? -EINVAL
: err
;
223 if (hpfs_sb(dir
->i_sb
)->sb_eas
< 2) return -EPERM
;
224 if (!new_valid_dev(rdev
))
228 fnode
= hpfs_alloc_fnode(dir
->i_sb
, hpfs_i(dir
)->i_dno
, &fno
, &bh
);
231 memset(&dee
, 0, sizeof dee
);
232 if (!(mode
& 0222)) dee
.read_only
= 1;
234 dee
.hidden
= name
[0] == '.';
236 dee
.creation_date
= dee
.write_date
= dee
.read_date
= gmt_to_local(dir
->i_sb
, get_seconds());
238 result
= new_inode(dir
->i_sb
);
242 hpfs_init_inode(result
);
244 hpfs_i(result
)->i_parent_dir
= dir
->i_ino
;
245 result
->i_ctime
.tv_sec
= result
->i_mtime
.tv_sec
= result
->i_atime
.tv_sec
= local_to_gmt(dir
->i_sb
, dee
.creation_date
);
246 result
->i_ctime
.tv_nsec
= 0;
247 result
->i_mtime
.tv_nsec
= 0;
248 result
->i_atime
.tv_nsec
= 0;
249 hpfs_i(result
)->i_ea_size
= 0;
250 result
->i_uid
= current
->fsuid
;
251 result
->i_gid
= current
->fsgid
;
254 result
->i_blocks
= 1;
255 init_special_inode(result
, mode
, rdev
);
257 mutex_lock(&hpfs_i(dir
)->i_mutex
);
258 r
= hpfs_add_dirent(dir
, (char *)name
, len
, &dee
, 0);
266 memcpy(fnode
->name
, name
, len
> 15 ? 15 : len
);
267 fnode
->up
= dir
->i_ino
;
268 mark_buffer_dirty(bh
);
270 insert_inode_hash(result
);
272 hpfs_write_inode_nolock(result
);
273 d_instantiate(dentry
, result
);
274 mutex_unlock(&hpfs_i(dir
)->i_mutex
);
279 mutex_unlock(&hpfs_i(dir
)->i_mutex
);
283 hpfs_free_sectors(dir
->i_sb
, fno
, 1);
289 static int hpfs_symlink(struct inode
*dir
, struct dentry
*dentry
, const char *symlink
)
291 const char *name
= dentry
->d_name
.name
;
292 unsigned len
= dentry
->d_name
.len
;
293 struct buffer_head
*bh
;
297 struct hpfs_dirent dee
;
298 struct inode
*result
;
300 if ((err
= hpfs_chk_name((char *)name
, &len
))) return err
==-ENOENT
? -EINVAL
: err
;
302 if (hpfs_sb(dir
->i_sb
)->sb_eas
< 2) {
307 fnode
= hpfs_alloc_fnode(dir
->i_sb
, hpfs_i(dir
)->i_dno
, &fno
, &bh
);
310 memset(&dee
, 0, sizeof dee
);
312 dee
.hidden
= name
[0] == '.';
314 dee
.creation_date
= dee
.write_date
= dee
.read_date
= gmt_to_local(dir
->i_sb
, get_seconds());
316 result
= new_inode(dir
->i_sb
);
320 hpfs_init_inode(result
);
321 hpfs_i(result
)->i_parent_dir
= dir
->i_ino
;
322 result
->i_ctime
.tv_sec
= result
->i_mtime
.tv_sec
= result
->i_atime
.tv_sec
= local_to_gmt(dir
->i_sb
, dee
.creation_date
);
323 result
->i_ctime
.tv_nsec
= 0;
324 result
->i_mtime
.tv_nsec
= 0;
325 result
->i_atime
.tv_nsec
= 0;
326 hpfs_i(result
)->i_ea_size
= 0;
327 result
->i_mode
= S_IFLNK
| 0777;
328 result
->i_uid
= current
->fsuid
;
329 result
->i_gid
= current
->fsgid
;
330 result
->i_blocks
= 1;
332 result
->i_size
= strlen(symlink
);
333 result
->i_op
= &page_symlink_inode_operations
;
334 result
->i_data
.a_ops
= &hpfs_symlink_aops
;
336 mutex_lock(&hpfs_i(dir
)->i_mutex
);
337 r
= hpfs_add_dirent(dir
, (char *)name
, len
, &dee
, 0);
345 memcpy(fnode
->name
, name
, len
> 15 ? 15 : len
);
346 fnode
->up
= dir
->i_ino
;
347 hpfs_set_ea(result
, fnode
, "SYMLINK", (char *)symlink
, strlen(symlink
));
348 mark_buffer_dirty(bh
);
351 insert_inode_hash(result
);
353 hpfs_write_inode_nolock(result
);
354 d_instantiate(dentry
, result
);
355 mutex_unlock(&hpfs_i(dir
)->i_mutex
);
359 mutex_unlock(&hpfs_i(dir
)->i_mutex
);
363 hpfs_free_sectors(dir
->i_sb
, fno
, 1);
369 static int hpfs_unlink(struct inode
*dir
, struct dentry
*dentry
)
371 const char *name
= dentry
->d_name
.name
;
372 unsigned len
= dentry
->d_name
.len
;
373 struct quad_buffer_head qbh
;
374 struct hpfs_dirent
*de
;
375 struct inode
*inode
= dentry
->d_inode
;
383 hpfs_adjust_length((char *)name
, &len
);
385 mutex_lock(&hpfs_i(inode
)->i_parent_mutex
);
386 mutex_lock(&hpfs_i(dir
)->i_mutex
);
388 de
= map_dirent(dir
, hpfs_i(dir
)->i_dno
, (char *)name
, len
, &dno
, &qbh
);
401 r
= hpfs_remove_dirent(dir
, dno
, de
, &qbh
, 1);
404 hpfs_error(dir
->i_sb
, "there was error when removing dirent");
407 case 2: /* no space for deleting, try to truncate file */
413 mutex_unlock(&hpfs_i(dir
)->i_mutex
);
414 mutex_unlock(&hpfs_i(inode
)->i_parent_mutex
);
416 spin_lock(&dentry
->d_lock
);
417 if (atomic_read(&dentry
->d_count
) > 1 ||
418 generic_permission(inode
, MAY_WRITE
, NULL
) ||
419 !S_ISREG(inode
->i_mode
) ||
420 get_write_access(inode
)) {
421 spin_unlock(&dentry
->d_lock
);
424 struct iattr newattrs
;
425 spin_unlock(&dentry
->d_lock
);
426 /*printk("HPFS: truncating file before delete.\n");*/
427 newattrs
.ia_size
= 0;
428 newattrs
.ia_valid
= ATTR_SIZE
| ATTR_CTIME
;
429 err
= notify_change(dentry
, &newattrs
);
430 put_write_access(inode
);
445 mutex_unlock(&hpfs_i(dir
)->i_mutex
);
446 mutex_unlock(&hpfs_i(inode
)->i_parent_mutex
);
451 static int hpfs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
453 const char *name
= dentry
->d_name
.name
;
454 unsigned len
= dentry
->d_name
.len
;
455 struct quad_buffer_head qbh
;
456 struct hpfs_dirent
*de
;
457 struct inode
*inode
= dentry
->d_inode
;
464 hpfs_adjust_length((char *)name
, &len
);
466 mutex_lock(&hpfs_i(inode
)->i_parent_mutex
);
467 mutex_lock(&hpfs_i(dir
)->i_mutex
);
469 de
= map_dirent(dir
, hpfs_i(dir
)->i_dno
, (char *)name
, len
, &dno
, &qbh
);
481 hpfs_count_dnodes(dir
->i_sb
, hpfs_i(inode
)->i_dno
, NULL
, NULL
, &n_items
);
487 r
= hpfs_remove_dirent(dir
, dno
, de
, &qbh
, 1);
490 hpfs_error(dir
->i_sb
, "there was error when removing dirent");
505 mutex_unlock(&hpfs_i(dir
)->i_mutex
);
506 mutex_unlock(&hpfs_i(inode
)->i_parent_mutex
);
511 static int hpfs_symlink_readpage(struct file
*file
, struct page
*page
)
513 char *link
= kmap(page
);
514 struct inode
*i
= page
->mapping
->host
;
516 struct buffer_head
*bh
;
521 if (!(fnode
= hpfs_map_fnode(i
->i_sb
, i
->i_ino
, &bh
)))
523 err
= hpfs_read_ea(i
->i_sb
, fnode
, "SYMLINK", link
, PAGE_SIZE
);
528 SetPageUptodate(page
);
541 const struct address_space_operations hpfs_symlink_aops
= {
542 .readpage
= hpfs_symlink_readpage
545 static int hpfs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
546 struct inode
*new_dir
, struct dentry
*new_dentry
)
548 char *old_name
= (char *)old_dentry
->d_name
.name
;
549 int old_len
= old_dentry
->d_name
.len
;
550 char *new_name
= (char *)new_dentry
->d_name
.name
;
551 int new_len
= new_dentry
->d_name
.len
;
552 struct inode
*i
= old_dentry
->d_inode
;
553 struct inode
*new_inode
= new_dentry
->d_inode
;
554 struct quad_buffer_head qbh
, qbh1
;
555 struct hpfs_dirent
*dep
, *nde
;
556 struct hpfs_dirent de
;
559 struct buffer_head
*bh
;
562 if ((err
= hpfs_chk_name((char *)new_name
, &new_len
))) return err
;
564 hpfs_adjust_length((char *)old_name
, &old_len
);
567 /* order doesn't matter, due to VFS exclusion */
568 mutex_lock(&hpfs_i(i
)->i_parent_mutex
);
570 mutex_lock(&hpfs_i(new_inode
)->i_parent_mutex
);
571 mutex_lock(&hpfs_i(old_dir
)->i_mutex
);
572 if (new_dir
!= old_dir
)
573 mutex_lock(&hpfs_i(new_dir
)->i_mutex
);
575 /* Erm? Moving over the empty non-busy directory is perfectly legal */
576 if (new_inode
&& S_ISDIR(new_inode
->i_mode
)) {
581 if (!(dep
= map_dirent(old_dir
, hpfs_i(old_dir
)->i_dno
, (char *)old_name
, old_len
, &dno
, &qbh
))) {
582 hpfs_error(i
->i_sb
, "lookup succeeded but map dirent failed");
587 de
.hidden
= new_name
[0] == '.';
591 if ((r
= hpfs_remove_dirent(old_dir
, dno
, dep
, &qbh
, 1)) != 2) {
592 if ((nde
= map_dirent(new_dir
, hpfs_i(new_dir
)->i_dno
, (char *)new_name
, new_len
, NULL
, &qbh1
))) {
593 clear_nlink(new_inode
);
595 memcpy(nde
->name
, new_name
, new_len
);
596 hpfs_mark_4buffers_dirty(&qbh1
);
600 hpfs_error(new_dir
->i_sb
, "hpfs_rename: could not find dirent");
604 err
= r
== 2 ? -ENOSPC
: r
== 1 ? -EFSERROR
: 0;
608 if (new_dir
== old_dir
) hpfs_brelse4(&qbh
);
610 hpfs_lock_creation(i
->i_sb
);
611 if ((r
= hpfs_add_dirent(new_dir
, new_name
, new_len
, &de
, 1))) {
612 hpfs_unlock_creation(i
->i_sb
);
613 if (r
== -1) hpfs_error(new_dir
->i_sb
, "hpfs_rename: dirent already exists!");
614 err
= r
== 1 ? -ENOSPC
: -EFSERROR
;
615 if (new_dir
!= old_dir
) hpfs_brelse4(&qbh
);
619 if (new_dir
== old_dir
)
620 if (!(dep
= map_dirent(old_dir
, hpfs_i(old_dir
)->i_dno
, (char *)old_name
, old_len
, &dno
, &qbh
))) {
621 hpfs_unlock_creation(i
->i_sb
);
622 hpfs_error(i
->i_sb
, "lookup succeeded but map dirent failed at #2");
627 if ((r
= hpfs_remove_dirent(old_dir
, dno
, dep
, &qbh
, 0))) {
628 hpfs_unlock_creation(i
->i_sb
);
629 hpfs_error(i
->i_sb
, "hpfs_rename: could not remove dirent");
630 err
= r
== 2 ? -ENOSPC
: -EFSERROR
;
633 hpfs_unlock_creation(i
->i_sb
);
636 hpfs_i(i
)->i_parent_dir
= new_dir
->i_ino
;
637 if (S_ISDIR(i
->i_mode
)) {
641 if ((fnode
= hpfs_map_fnode(i
->i_sb
, i
->i_ino
, &bh
))) {
642 fnode
->up
= new_dir
->i_ino
;
643 fnode
->len
= new_len
;
644 memcpy(fnode
->name
, new_name
, new_len
>15?15:new_len
);
645 if (new_len
< 15) memset(&fnode
->name
[new_len
], 0, 15 - new_len
);
646 mark_buffer_dirty(bh
);
649 hpfs_i(i
)->i_conv
= hpfs_sb(i
->i_sb
)->sb_conv
;
650 hpfs_decide_conv(i
, (char *)new_name
, new_len
);
652 if (old_dir
!= new_dir
)
653 mutex_unlock(&hpfs_i(new_dir
)->i_mutex
);
654 mutex_unlock(&hpfs_i(old_dir
)->i_mutex
);
655 mutex_unlock(&hpfs_i(i
)->i_parent_mutex
);
657 mutex_unlock(&hpfs_i(new_inode
)->i_parent_mutex
);
662 const struct inode_operations hpfs_dir_iops
=
664 .create
= hpfs_create
,
665 .lookup
= hpfs_lookup
,
666 .unlink
= hpfs_unlink
,
667 .symlink
= hpfs_symlink
,
671 .rename
= hpfs_rename
,
672 .setattr
= hpfs_notify_change
,