1/*
2 * linux/fs/ext2/namei.c
3 *
4 * Rewrite to pagecache. Almost all code had been changed, so blame me
5 * if the things go wrong. Please, send bug reports to
6 * viro@parcelfarce.linux.theplanet.co.uk
7 *
8 * Stuff here is basically a glue between the VFS and generic UNIXish
9 * filesystem that keeps everything in pagecache. All knowledge of the
10 * directory layout is in fs/ext2/dir.c - it turned out to be easily separatable
11 * and it's easier to debug that way. In principle we might want to
12 * generalize that a bit and turn it into a library. Or not.
13 *
14 * The only non-static object here is ext2_dir_inode_operations.
15 *
16 * TODO: get rid of kmap() use, add readahead.
17 *
18 * Copyright (C) 1992, 1993, 1994, 1995
19 * Remy Card (card@masi.ibp.fr)
20 * Laboratoire MASI - Institut Blaise Pascal
21 * Universite Pierre et Marie Curie (Paris VI)
22 *
23 *  from
24 *
25 *  linux/fs/minix/namei.c
26 *
27 *  Copyright (C) 1991, 1992  Linus Torvalds
28 *
29 *  Big-endian to little-endian byte-swapping/bitmaps by
30 *        David S. Miller (davem@caip.rutgers.edu), 1995
31 */
32
33#include <linux/pagemap.h>
34#include <linux/quotaops.h>
35#include "ext2.h"
36#include "xattr.h"
37#include "acl.h"
38
39static inline int ext2_add_nondir(struct dentry *dentry, struct inode *inode)
40{
41	int err = ext2_add_link(dentry, inode);
42	if (!err) {
43		unlock_new_inode(inode);
44		d_instantiate(dentry, inode);
45		return 0;
46	}
47	inode_dec_link_count(inode);
48	unlock_new_inode(inode);
49	iput(inode);
50	return err;
51}
52
53/*
54 * Methods themselves.
55 */
56
57static struct dentry *ext2_lookup(struct inode * dir, struct dentry *dentry, unsigned int flags)
58{
59	struct inode * inode;
60	ino_t ino;
61
62	if (dentry->d_name.len > EXT2_NAME_LEN)
63		return ERR_PTR(-ENAMETOOLONG);
64
65	ino = ext2_inode_by_name(dir, &dentry->d_name);
66	inode = NULL;
67	if (ino) {
68		inode = ext2_iget(dir->i_sb, ino);
69		if (inode == ERR_PTR(-ESTALE)) {
70			ext2_error(dir->i_sb, __func__,
71					"deleted inode referenced: %lu",
72					(unsigned long) ino);
73			return ERR_PTR(-EIO);
74		}
75	}
76	return d_splice_alias(inode, dentry);
77}
78
79struct dentry *ext2_get_parent(struct dentry *child)
80{
81	struct qstr dotdot = QSTR_INIT("..", 2);
82	unsigned long ino = ext2_inode_by_name(d_inode(child), &dotdot);
83	if (!ino)
84		return ERR_PTR(-ENOENT);
85	return d_obtain_alias(ext2_iget(d_inode(child)->i_sb, ino));
86}
87
88/*
89 * By the time this is called, we already have created
90 * the directory cache entry for the new file, but it
91 * is so far negative - it has no inode.
92 *
93 * If the create succeeds, we fill in the inode information
94 * with d_instantiate().
95 */
96static int ext2_create (struct inode * dir, struct dentry * dentry, umode_t mode, bool excl)
97{
98	struct inode *inode;
99	int err;
100
101	err = dquot_initialize(dir);
102	if (err)
103		return err;
104
105	inode = ext2_new_inode(dir, mode, &dentry->d_name);
106	if (IS_ERR(inode))
107		return PTR_ERR(inode);
108
109	inode->i_op = &ext2_file_inode_operations;
110	if (test_opt(inode->i_sb, NOBH)) {
111		inode->i_mapping->a_ops = &ext2_nobh_aops;
112		inode->i_fop = &ext2_file_operations;
113	} else {
114		inode->i_mapping->a_ops = &ext2_aops;
115		inode->i_fop = &ext2_file_operations;
116	}
117	mark_inode_dirty(inode);
118	return ext2_add_nondir(dentry, inode);
119}
120
121static int ext2_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode)
122{
123	struct inode *inode = ext2_new_inode(dir, mode, NULL);
124	if (IS_ERR(inode))
125		return PTR_ERR(inode);
126
127	inode->i_op = &ext2_file_inode_operations;
128	if (test_opt(inode->i_sb, NOBH)) {
129		inode->i_mapping->a_ops = &ext2_nobh_aops;
130		inode->i_fop = &ext2_file_operations;
131	} else {
132		inode->i_mapping->a_ops = &ext2_aops;
133		inode->i_fop = &ext2_file_operations;
134	}
135	mark_inode_dirty(inode);
136	d_tmpfile(dentry, inode);
137	unlock_new_inode(inode);
138	return 0;
139}
140
141static int ext2_mknod (struct inode * dir, struct dentry *dentry, umode_t mode, dev_t rdev)
142{
143	struct inode * inode;
144	int err;
145
146	err = dquot_initialize(dir);
147	if (err)
148		return err;
149
150	inode = ext2_new_inode (dir, mode, &dentry->d_name);
151	err = PTR_ERR(inode);
152	if (!IS_ERR(inode)) {
153		init_special_inode(inode, inode->i_mode, rdev);
154#ifdef CONFIG_EXT2_FS_XATTR
155		inode->i_op = &ext2_special_inode_operations;
156#endif
157		mark_inode_dirty(inode);
158		err = ext2_add_nondir(dentry, inode);
159	}
160	return err;
161}
162
163static int ext2_symlink (struct inode * dir, struct dentry * dentry,
164	const char * symname)
165{
166	struct super_block * sb = dir->i_sb;
167	int err = -ENAMETOOLONG;
168	unsigned l = strlen(symname)+1;
169	struct inode * inode;
170
171	if (l > sb->s_blocksize)
172		goto out;
173
174	err = dquot_initialize(dir);
175	if (err)
176		goto out;
177
178	inode = ext2_new_inode (dir, S_IFLNK | S_IRWXUGO, &dentry->d_name);
179	err = PTR_ERR(inode);
180	if (IS_ERR(inode))
181		goto out;
182
183	if (l > sizeof (EXT2_I(inode)->i_data)) {
184		/* slow symlink */
185		inode->i_op = &ext2_symlink_inode_operations;
186		if (test_opt(inode->i_sb, NOBH))
187			inode->i_mapping->a_ops = &ext2_nobh_aops;
188		else
189			inode->i_mapping->a_ops = &ext2_aops;
190		err = page_symlink(inode, symname, l);
191		if (err)
192			goto out_fail;
193	} else {
194		/* fast symlink */
195		inode->i_op = &ext2_fast_symlink_inode_operations;
196		inode->i_link = (char*)EXT2_I(inode)->i_data;
197		memcpy(inode->i_link, symname, l);
198		inode->i_size = l-1;
199	}
200	mark_inode_dirty(inode);
201
202	err = ext2_add_nondir(dentry, inode);
203out:
204	return err;
205
206out_fail:
207	inode_dec_link_count(inode);
208	unlock_new_inode(inode);
209	iput (inode);
210	goto out;
211}
212
213static int ext2_link (struct dentry * old_dentry, struct inode * dir,
214	struct dentry *dentry)
215{
216	struct inode *inode = d_inode(old_dentry);
217	int err;
218
219	err = dquot_initialize(dir);
220	if (err)
221		return err;
222
223	inode->i_ctime = CURRENT_TIME_SEC;
224	inode_inc_link_count(inode);
225	ihold(inode);
226
227	err = ext2_add_link(dentry, inode);
228	if (!err) {
229		d_instantiate(dentry, inode);
230		return 0;
231	}
232	inode_dec_link_count(inode);
233	iput(inode);
234	return err;
235}
236
237static int ext2_mkdir(struct inode * dir, struct dentry * dentry, umode_t mode)
238{
239	struct inode * inode;
240	int err;
241
242	err = dquot_initialize(dir);
243	if (err)
244		return err;
245
246	inode_inc_link_count(dir);
247
248	inode = ext2_new_inode(dir, S_IFDIR | mode, &dentry->d_name);
249	err = PTR_ERR(inode);
250	if (IS_ERR(inode))
251		goto out_dir;
252
253	inode->i_op = &ext2_dir_inode_operations;
254	inode->i_fop = &ext2_dir_operations;
255	if (test_opt(inode->i_sb, NOBH))
256		inode->i_mapping->a_ops = &ext2_nobh_aops;
257	else
258		inode->i_mapping->a_ops = &ext2_aops;
259
260	inode_inc_link_count(inode);
261
262	err = ext2_make_empty(inode, dir);
263	if (err)
264		goto out_fail;
265
266	err = ext2_add_link(dentry, inode);
267	if (err)
268		goto out_fail;
269
270	unlock_new_inode(inode);
271	d_instantiate(dentry, inode);
272out:
273	return err;
274
275out_fail:
276	inode_dec_link_count(inode);
277	inode_dec_link_count(inode);
278	unlock_new_inode(inode);
279	iput(inode);
280out_dir:
281	inode_dec_link_count(dir);
282	goto out;
283}
284
285static int ext2_unlink(struct inode * dir, struct dentry *dentry)
286{
287	struct inode * inode = d_inode(dentry);
288	struct ext2_dir_entry_2 * de;
289	struct page * page;
290	int err;
291
292	err = dquot_initialize(dir);
293	if (err)
294		goto out;
295
296	de = ext2_find_entry (dir, &dentry->d_name, &page);
297	if (!de) {
298		err = -ENOENT;
299		goto out;
300	}
301
302	err = ext2_delete_entry (de, page);
303	if (err)
304		goto out;
305
306	inode->i_ctime = dir->i_ctime;
307	inode_dec_link_count(inode);
308	err = 0;
309out:
310	return err;
311}
312
313static int ext2_rmdir (struct inode * dir, struct dentry *dentry)
314{
315	struct inode * inode = d_inode(dentry);
316	int err = -ENOTEMPTY;
317
318	if (ext2_empty_dir(inode)) {
319		err = ext2_unlink(dir, dentry);
320		if (!err) {
321			inode->i_size = 0;
322			inode_dec_link_count(inode);
323			inode_dec_link_count(dir);
324		}
325	}
326	return err;
327}
328
329static int ext2_rename (struct inode * old_dir, struct dentry * old_dentry,
330	struct inode * new_dir,	struct dentry * new_dentry )
331{
332	struct inode * old_inode = d_inode(old_dentry);
333	struct inode * new_inode = d_inode(new_dentry);
334	struct page * dir_page = NULL;
335	struct ext2_dir_entry_2 * dir_de = NULL;
336	struct page * old_page;
337	struct ext2_dir_entry_2 * old_de;
338	int err;
339
340	err = dquot_initialize(old_dir);
341	if (err)
342		goto out;
343
344	err = dquot_initialize(new_dir);
345	if (err)
346		goto out;
347
348	old_de = ext2_find_entry (old_dir, &old_dentry->d_name, &old_page);
349	if (!old_de) {
350		err = -ENOENT;
351		goto out;
352	}
353
354	if (S_ISDIR(old_inode->i_mode)) {
355		err = -EIO;
356		dir_de = ext2_dotdot(old_inode, &dir_page);
357		if (!dir_de)
358			goto out_old;
359	}
360
361	if (new_inode) {
362		struct page *new_page;
363		struct ext2_dir_entry_2 *new_de;
364
365		err = -ENOTEMPTY;
366		if (dir_de && !ext2_empty_dir (new_inode))
367			goto out_dir;
368
369		err = -ENOENT;
370		new_de = ext2_find_entry (new_dir, &new_dentry->d_name, &new_page);
371		if (!new_de)
372			goto out_dir;
373		ext2_set_link(new_dir, new_de, new_page, old_inode, 1);
374		new_inode->i_ctime = CURRENT_TIME_SEC;
375		if (dir_de)
376			drop_nlink(new_inode);
377		inode_dec_link_count(new_inode);
378	} else {
379		err = ext2_add_link(new_dentry, old_inode);
380		if (err)
381			goto out_dir;
382		if (dir_de)
383			inode_inc_link_count(new_dir);
384	}
385
386	/*
387	 * Like most other Unix systems, set the ctime for inodes on a
388 	 * rename.
389	 */
390	old_inode->i_ctime = CURRENT_TIME_SEC;
391	mark_inode_dirty(old_inode);
392
393	ext2_delete_entry (old_de, old_page);
394
395	if (dir_de) {
396		if (old_dir != new_dir)
397			ext2_set_link(old_inode, dir_de, dir_page, new_dir, 0);
398		else {
399			kunmap(dir_page);
400			page_cache_release(dir_page);
401		}
402		inode_dec_link_count(old_dir);
403	}
404	return 0;
405
406
407out_dir:
408	if (dir_de) {
409		kunmap(dir_page);
410		page_cache_release(dir_page);
411	}
412out_old:
413	kunmap(old_page);
414	page_cache_release(old_page);
415out:
416	return err;
417}
418
419const struct inode_operations ext2_dir_inode_operations = {
420	.create		= ext2_create,
421	.lookup		= ext2_lookup,
422	.link		= ext2_link,
423	.unlink		= ext2_unlink,
424	.symlink	= ext2_symlink,
425	.mkdir		= ext2_mkdir,
426	.rmdir		= ext2_rmdir,
427	.mknod		= ext2_mknod,
428	.rename		= ext2_rename,
429#ifdef CONFIG_EXT2_FS_XATTR
430	.setxattr	= generic_setxattr,
431	.getxattr	= generic_getxattr,
432	.listxattr	= ext2_listxattr,
433	.removexattr	= generic_removexattr,
434#endif
435	.setattr	= ext2_setattr,
436	.get_acl	= ext2_get_acl,
437	.set_acl	= ext2_set_acl,
438	.tmpfile	= ext2_tmpfile,
439};
440
441const struct inode_operations ext2_special_inode_operations = {
442#ifdef CONFIG_EXT2_FS_XATTR
443	.setxattr	= generic_setxattr,
444	.getxattr	= generic_getxattr,
445	.listxattr	= ext2_listxattr,
446	.removexattr	= generic_removexattr,
447#endif
448	.setattr	= ext2_setattr,
449	.get_acl	= ext2_get_acl,
450	.set_acl	= ext2_set_acl,
451};
452