2 * linux/fs/ext2/namei.c
4 * Rewrite to pagecache. Almost all code had been changed, so blame me
5 * if the things go wrong. Please, send bug reports to viro@math.psu.edu
7 * Stuff here is basically a glue between the VFS and generic UNIXish
8 * filesystem that keeps everything in pagecache. All knowledge of the
9 * directory layout is in fs/ext2/dir.c - it turned out to be easily separatable
10 * and it's easier to debug that way. In principle we might want to
11 * generalize that a bit and turn it into a library. Or not.
13 * The only non-static object here is ext2_dir_inode_operations.
15 * TODO: get rid of kmap() use, add readahead.
17 * Copyright (C) 1992, 1993, 1994, 1995
18 * Remy Card (card@masi.ibp.fr)
19 * Laboratoire MASI - Institut Blaise Pascal
20 * Universite Pierre et Marie Curie (Paris VI)
24 * linux/fs/minix/namei.c
26 * Copyright (C) 1991, 1992 Linus Torvalds
28 * Big-endian to little-endian byte-swapping/bitmaps by
29 * David S. Miller (davem@caip.rutgers.edu), 1995
32 #include <linux/pagemap.h>
38 * Couple of helper functions - make the code slightly cleaner.
41 static inline void ext2_inc_count(struct inode *inode)
44 mark_inode_dirty(inode);
47 static inline void ext2_dec_count(struct inode *inode)
50 mark_inode_dirty(inode);
53 static inline int ext2_add_nondir(struct dentry *dentry, struct inode *inode)
55 int err = ext2_add_link(dentry, inode);
57 d_instantiate(dentry, inode);
60 ext2_dec_count(inode);
69 static struct dentry *ext2_lookup(struct inode * dir, struct dentry *dentry, struct nameidata *nd)
74 if (dentry->d_name.len > EXT2_NAME_LEN)
75 return ERR_PTR(-ENAMETOOLONG);
77 ino = ext2_inode_by_name(dir, dentry);
80 inode = iget(dir->i_sb, ino);
82 return ERR_PTR(-EACCES);
85 return d_splice_alias(inode, dentry);
90 struct dentry *ext2_get_parent(struct dentry *child)
93 struct dentry *parent;
97 dotdot.d_name.name = "..";
98 dotdot.d_name.len = 2;
100 ino = ext2_inode_by_name(child->d_inode, &dotdot);
102 return ERR_PTR(-ENOENT);
103 inode = iget(child->d_inode->i_sb, ino);
106 return ERR_PTR(-EACCES);
107 parent = d_alloc_anon(inode);
110 parent = ERR_PTR(-ENOMEM);
116 * By the time this is called, we already have created
117 * the directory cache entry for the new file, but it
118 * is so far negative - it has no inode.
120 * If the create succeeds, we fill in the inode information
121 * with d_instantiate().
123 static int ext2_create (struct inode * dir, struct dentry * dentry, int mode, struct nameidata *nd)
125 struct inode * inode = ext2_new_inode (dir, mode);
126 int err = PTR_ERR(inode);
127 if (!IS_ERR(inode)) {
128 inode->i_op = &ext2_file_inode_operations;
129 inode->i_fop = &ext2_file_operations;
130 if (test_opt(inode->i_sb, NOBH))
131 inode->i_mapping->a_ops = &ext2_nobh_aops;
133 inode->i_mapping->a_ops = &ext2_aops;
134 mark_inode_dirty(inode);
135 err = ext2_add_nondir(dentry, inode);
140 static int ext2_mknod (struct inode * dir, struct dentry *dentry, int mode, dev_t rdev)
142 struct inode * inode;
145 if (!new_valid_dev(rdev))
148 inode = ext2_new_inode (dir, mode);
149 err = PTR_ERR(inode);
150 if (!IS_ERR(inode)) {
151 init_special_inode(inode, inode->i_mode, rdev);
152 #ifdef CONFIG_EXT2_FS_XATTR
153 inode->i_op = &ext2_special_inode_operations;
155 mark_inode_dirty(inode);
156 err = ext2_add_nondir(dentry, inode);
161 static int ext2_symlink (struct inode * dir, struct dentry * dentry,
162 const char * symname)
164 struct super_block * sb = dir->i_sb;
165 int err = -ENAMETOOLONG;
166 unsigned l = strlen(symname)+1;
167 struct inode * inode;
169 if (l > sb->s_blocksize)
172 inode = ext2_new_inode (dir, S_IFLNK | S_IRWXUGO);
173 err = PTR_ERR(inode);
177 if (l > sizeof (EXT2_I(inode)->i_data)) {
179 inode->i_op = &ext2_symlink_inode_operations;
180 if (test_opt(inode->i_sb, NOBH))
181 inode->i_mapping->a_ops = &ext2_nobh_aops;
183 inode->i_mapping->a_ops = &ext2_aops;
184 err = page_symlink(inode, symname, l);
189 inode->i_op = &ext2_fast_symlink_inode_operations;
190 memcpy((char*)(EXT2_I(inode)->i_data),symname,l);
193 mark_inode_dirty(inode);
195 err = ext2_add_nondir(dentry, inode);
200 ext2_dec_count(inode);
205 static int ext2_link (struct dentry * old_dentry, struct inode * dir,
206 struct dentry *dentry)
208 struct inode *inode = old_dentry->d_inode;
210 if (inode->i_nlink >= EXT2_LINK_MAX)
213 inode->i_ctime = CURRENT_TIME;
214 ext2_inc_count(inode);
215 atomic_inc(&inode->i_count);
217 return ext2_add_nondir(dentry, inode);
220 static int ext2_mkdir(struct inode * dir, struct dentry * dentry, int mode)
222 struct inode * inode;
225 if (dir->i_nlink >= EXT2_LINK_MAX)
230 inode = ext2_new_inode (dir, S_IFDIR | mode);
231 err = PTR_ERR(inode);
235 inode->i_op = &ext2_dir_inode_operations;
236 inode->i_fop = &ext2_dir_operations;
237 if (test_opt(inode->i_sb, NOBH))
238 inode->i_mapping->a_ops = &ext2_nobh_aops;
240 inode->i_mapping->a_ops = &ext2_aops;
242 ext2_inc_count(inode);
244 err = ext2_make_empty(inode, dir);
248 err = ext2_add_link(dentry, inode);
252 d_instantiate(dentry, inode);
257 ext2_dec_count(inode);
258 ext2_dec_count(inode);
265 static int ext2_unlink(struct inode * dir, struct dentry *dentry)
267 struct inode * inode = dentry->d_inode;
268 struct ext2_dir_entry_2 * de;
272 de = ext2_find_entry (dir, dentry, &page);
276 err = ext2_delete_entry (de, page);
280 inode->i_ctime = dir->i_ctime;
281 ext2_dec_count(inode);
287 static int ext2_rmdir (struct inode * dir, struct dentry *dentry)
289 struct inode * inode = dentry->d_inode;
290 int err = -ENOTEMPTY;
292 if (ext2_empty_dir(inode)) {
293 err = ext2_unlink(dir, dentry);
296 ext2_dec_count(inode);
303 static int ext2_rename (struct inode * old_dir, struct dentry * old_dentry,
304 struct inode * new_dir, struct dentry * new_dentry )
306 struct inode * old_inode = old_dentry->d_inode;
307 struct inode * new_inode = new_dentry->d_inode;
308 struct page * dir_page = NULL;
309 struct ext2_dir_entry_2 * dir_de = NULL;
310 struct page * old_page;
311 struct ext2_dir_entry_2 * old_de;
314 old_de = ext2_find_entry (old_dir, old_dentry, &old_page);
318 if (S_ISDIR(old_inode->i_mode)) {
320 dir_de = ext2_dotdot(old_inode, &dir_page);
326 struct page *new_page;
327 struct ext2_dir_entry_2 *new_de;
330 if (dir_de && !ext2_empty_dir (new_inode))
334 new_de = ext2_find_entry (new_dir, new_dentry, &new_page);
337 ext2_inc_count(old_inode);
338 ext2_set_link(new_dir, new_de, new_page, old_inode);
339 new_inode->i_ctime = CURRENT_TIME;
341 new_inode->i_nlink--;
342 ext2_dec_count(new_inode);
346 if (new_dir->i_nlink >= EXT2_LINK_MAX)
349 ext2_inc_count(old_inode);
350 err = ext2_add_link(new_dentry, old_inode);
352 ext2_dec_count(old_inode);
356 ext2_inc_count(new_dir);
360 * Like most other Unix systems, set the ctime for inodes on a
362 * ext2_dec_count() will mark the inode dirty.
364 old_inode->i_ctime = CURRENT_TIME;
366 ext2_delete_entry (old_de, old_page);
367 ext2_dec_count(old_inode);
370 ext2_set_link(old_inode, dir_de, dir_page, new_dir);
371 ext2_dec_count(old_dir);
379 page_cache_release(dir_page);
383 page_cache_release(old_page);
388 struct inode_operations ext2_dir_inode_operations = {
389 .create = ext2_create,
390 .lookup = ext2_lookup,
392 .unlink = ext2_unlink,
393 .symlink = ext2_symlink,
397 .rename = ext2_rename,
398 .setxattr = ext2_setxattr,
399 .getxattr = ext2_getxattr,
400 .listxattr = ext2_listxattr,
401 .removexattr = ext2_removexattr,
402 .setattr = ext2_setattr,
403 .permission = ext2_permission,
406 struct inode_operations ext2_special_inode_operations = {
407 .setxattr = ext2_setxattr,
408 .getxattr = ext2_getxattr,
409 .listxattr = ext2_listxattr,
410 .removexattr = ext2_removexattr,
411 .setattr = ext2_setattr,
412 .permission = ext2_permission,