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,