3a769d56c6891e6e5d2e93a77269336ece7a3cac
[linux-3.10.git] / fs / ufs / namei.c
1 /*
2  * linux/fs/ufs/namei.c
3  *
4  * Migration to usage of "page cache" on May 2006 by
5  * Evgeniy Dushistov <dushistov@mail.ru> based on ext2 code base.
6  *
7  * Copyright (C) 1998
8  * Daniel Pirkl <daniel.pirkl@email.cz>
9  * Charles University, Faculty of Mathematics and Physics
10  *
11  *  from
12  *
13  *  linux/fs/ext2/namei.c
14  *
15  * Copyright (C) 1992, 1993, 1994, 1995
16  * Remy Card (card@masi.ibp.fr)
17  * Laboratoire MASI - Institut Blaise Pascal
18  * Universite Pierre et Marie Curie (Paris VI)
19  *
20  *  from
21  *
22  *  linux/fs/minix/namei.c
23  *
24  *  Copyright (C) 1991, 1992  Linus Torvalds
25  *
26  *  Big-endian to little-endian byte-swapping/bitmaps by
27  *        David S. Miller (davem@caip.rutgers.edu), 1995
28  */
29
30 #include <linux/time.h>
31 #include <linux/fs.h>
32
33 #include "ufs_fs.h"
34 #include "ufs.h"
35 #include "util.h"
36
37 static inline int ufs_add_nondir(struct dentry *dentry, struct inode *inode)
38 {
39         int err = ufs_add_link(dentry, inode);
40         if (!err) {
41                 d_instantiate(dentry, inode);
42                 return 0;
43         }
44         inode_dec_link_count(inode);
45         iput(inode);
46         return err;
47 }
48
49 static struct dentry *ufs_lookup(struct inode * dir, struct dentry *dentry, struct nameidata *nd)
50 {
51         struct inode * inode = NULL;
52         ino_t ino;
53         
54         if (dentry->d_name.len > UFS_MAXNAMLEN)
55                 return ERR_PTR(-ENAMETOOLONG);
56
57         lock_ufs(dir->i_sb);
58         ino = ufs_inode_by_name(dir, &dentry->d_name);
59         if (ino) {
60                 inode = ufs_iget(dir->i_sb, ino);
61                 if (IS_ERR(inode)) {
62                         unlock_ufs(dir->i_sb);
63                         return ERR_CAST(inode);
64                 }
65         }
66         unlock_ufs(dir->i_sb);
67         d_add(dentry, inode);
68         return NULL;
69 }
70
71 /*
72  * By the time this is called, we already have created
73  * the directory cache entry for the new file, but it
74  * is so far negative - it has no inode.
75  *
76  * If the create succeeds, we fill in the inode information
77  * with d_instantiate(). 
78  */
79 static int ufs_create (struct inode * dir, struct dentry * dentry, int mode,
80                 struct nameidata *nd)
81 {
82         struct inode *inode;
83         int err;
84
85         UFSD("BEGIN\n");
86
87         inode = ufs_new_inode(dir, mode);
88         err = PTR_ERR(inode);
89
90         if (!IS_ERR(inode)) {
91                 inode->i_op = &ufs_file_inode_operations;
92                 inode->i_fop = &ufs_file_operations;
93                 inode->i_mapping->a_ops = &ufs_aops;
94                 mark_inode_dirty(inode);
95                 lock_ufs(dir->i_sb);
96                 err = ufs_add_nondir(dentry, inode);
97                 unlock_ufs(dir->i_sb);
98         }
99         UFSD("END: err=%d\n", err);
100         return err;
101 }
102
103 static int ufs_mknod (struct inode * dir, struct dentry *dentry, int mode, dev_t rdev)
104 {
105         struct inode *inode;
106         int err;
107
108         if (!old_valid_dev(rdev))
109                 return -EINVAL;
110
111         inode = ufs_new_inode(dir, mode);
112         err = PTR_ERR(inode);
113         if (!IS_ERR(inode)) {
114                 init_special_inode(inode, mode, rdev);
115                 ufs_set_inode_dev(inode->i_sb, UFS_I(inode), rdev);
116                 mark_inode_dirty(inode);
117                 lock_ufs(dir->i_sb);
118                 err = ufs_add_nondir(dentry, inode);
119                 unlock_ufs(dir->i_sb);
120         }
121         return err;
122 }
123
124 static int ufs_symlink (struct inode * dir, struct dentry * dentry,
125         const char * symname)
126 {
127         struct super_block * sb = dir->i_sb;
128         int err = -ENAMETOOLONG;
129         unsigned l = strlen(symname)+1;
130         struct inode * inode;
131
132         if (l > sb->s_blocksize)
133                 goto out_notlocked;
134
135         lock_ufs(dir->i_sb);
136         inode = ufs_new_inode(dir, S_IFLNK | S_IRWXUGO);
137         err = PTR_ERR(inode);
138         if (IS_ERR(inode))
139                 goto out;
140
141         if (l > UFS_SB(sb)->s_uspi->s_maxsymlinklen) {
142                 /* slow symlink */
143                 inode->i_op = &ufs_symlink_inode_operations;
144                 inode->i_mapping->a_ops = &ufs_aops;
145                 err = page_symlink(inode, symname, l);
146                 if (err)
147                         goto out_fail;
148         } else {
149                 /* fast symlink */
150                 inode->i_op = &ufs_fast_symlink_inode_operations;
151                 memcpy(UFS_I(inode)->i_u1.i_symlink, symname, l);
152                 inode->i_size = l-1;
153         }
154         mark_inode_dirty(inode);
155
156         err = ufs_add_nondir(dentry, inode);
157 out:
158         unlock_ufs(dir->i_sb);
159 out_notlocked:
160         return err;
161
162 out_fail:
163         inode_dec_link_count(inode);
164         iput(inode);
165         goto out;
166 }
167
168 static int ufs_link (struct dentry * old_dentry, struct inode * dir,
169         struct dentry *dentry)
170 {
171         struct inode *inode = old_dentry->d_inode;
172         int error;
173
174         lock_ufs(dir->i_sb);
175         if (inode->i_nlink >= UFS_LINK_MAX) {
176                 unlock_ufs(dir->i_sb);
177                 return -EMLINK;
178         }
179
180         inode->i_ctime = CURRENT_TIME_SEC;
181         inode_inc_link_count(inode);
182         ihold(inode);
183
184         error = ufs_add_nondir(dentry, inode);
185         unlock_ufs(dir->i_sb);
186         return error;
187 }
188
189 static int ufs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
190 {
191         struct inode * inode;
192         int err = -EMLINK;
193
194         if (dir->i_nlink >= UFS_LINK_MAX)
195                 goto out;
196
197         lock_ufs(dir->i_sb);
198         inode_inc_link_count(dir);
199
200         inode = ufs_new_inode(dir, S_IFDIR|mode);
201         err = PTR_ERR(inode);
202         if (IS_ERR(inode))
203                 goto out_dir;
204
205         inode->i_op = &ufs_dir_inode_operations;
206         inode->i_fop = &ufs_dir_operations;
207         inode->i_mapping->a_ops = &ufs_aops;
208
209         inode_inc_link_count(inode);
210
211         err = ufs_make_empty(inode, dir);
212         if (err)
213                 goto out_fail;
214
215         err = ufs_add_link(dentry, inode);
216         if (err)
217                 goto out_fail;
218         unlock_ufs(dir->i_sb);
219
220         d_instantiate(dentry, inode);
221 out:
222         return err;
223
224 out_fail:
225         inode_dec_link_count(inode);
226         inode_dec_link_count(inode);
227         iput (inode);
228 out_dir:
229         inode_dec_link_count(dir);
230         unlock_ufs(dir->i_sb);
231         goto out;
232 }
233
234 static int ufs_unlink(struct inode *dir, struct dentry *dentry)
235 {
236         struct inode * inode = dentry->d_inode;
237         struct ufs_dir_entry *de;
238         struct page *page;
239         int err = -ENOENT;
240
241         de = ufs_find_entry(dir, &dentry->d_name, &page);
242         if (!de)
243                 goto out;
244
245         err = ufs_delete_entry(dir, de, page);
246         if (err)
247                 goto out;
248
249         inode->i_ctime = dir->i_ctime;
250         inode_dec_link_count(inode);
251         err = 0;
252 out:
253         return err;
254 }
255
256 static int ufs_rmdir (struct inode * dir, struct dentry *dentry)
257 {
258         struct inode * inode = dentry->d_inode;
259         int err= -ENOTEMPTY;
260
261         dentry_unhash(dentry);
262
263         lock_ufs(dir->i_sb);
264         if (ufs_empty_dir (inode)) {
265                 err = ufs_unlink(dir, dentry);
266                 if (!err) {
267                         inode->i_size = 0;
268                         inode_dec_link_count(inode);
269                         inode_dec_link_count(dir);
270                 }
271         }
272         unlock_ufs(dir->i_sb);
273         return err;
274 }
275
276 static int ufs_rename(struct inode *old_dir, struct dentry *old_dentry,
277                       struct inode *new_dir, struct dentry *new_dentry)
278 {
279         struct inode *old_inode = old_dentry->d_inode;
280         struct inode *new_inode = new_dentry->d_inode;
281         struct page *dir_page = NULL;
282         struct ufs_dir_entry * dir_de = NULL;
283         struct page *old_page;
284         struct ufs_dir_entry *old_de;
285         int err = -ENOENT;
286
287         old_de = ufs_find_entry(old_dir, &old_dentry->d_name, &old_page);
288         if (!old_de)
289                 goto out;
290
291         if (S_ISDIR(old_inode->i_mode)) {
292                 err = -EIO;
293                 dir_de = ufs_dotdot(old_inode, &dir_page);
294                 if (!dir_de)
295                         goto out_old;
296         }
297
298         if (new_inode) {
299                 struct page *new_page;
300                 struct ufs_dir_entry *new_de;
301
302                 err = -ENOTEMPTY;
303                 if (dir_de && !ufs_empty_dir(new_inode))
304                         goto out_dir;
305
306                 err = -ENOENT;
307                 new_de = ufs_find_entry(new_dir, &new_dentry->d_name, &new_page);
308                 if (!new_de)
309                         goto out_dir;
310                 ufs_set_link(new_dir, new_de, new_page, old_inode);
311                 new_inode->i_ctime = CURRENT_TIME_SEC;
312                 if (dir_de)
313                         drop_nlink(new_inode);
314                 inode_dec_link_count(new_inode);
315         } else {
316                 if (dir_de) {
317                         err = -EMLINK;
318                         if (new_dir->i_nlink >= UFS_LINK_MAX)
319                                 goto out_dir;
320                 }
321                 err = ufs_add_link(new_dentry, old_inode);
322                 if (err)
323                         goto out_dir;
324                 if (dir_de)
325                         inode_inc_link_count(new_dir);
326         }
327
328         /*
329          * Like most other Unix systems, set the ctime for inodes on a
330          * rename.
331          */
332         old_inode->i_ctime = CURRENT_TIME_SEC;
333
334         ufs_delete_entry(old_dir, old_de, old_page);
335         mark_inode_dirty(old_inode);
336
337         if (dir_de) {
338                 ufs_set_link(old_inode, dir_de, dir_page, new_dir);
339                 inode_dec_link_count(old_dir);
340         }
341         return 0;
342
343
344 out_dir:
345         if (dir_de) {
346                 kunmap(dir_page);
347                 page_cache_release(dir_page);
348         }
349 out_old:
350         kunmap(old_page);
351         page_cache_release(old_page);
352 out:
353         return err;
354 }
355
356 const struct inode_operations ufs_dir_inode_operations = {
357         .create         = ufs_create,
358         .lookup         = ufs_lookup,
359         .link           = ufs_link,
360         .unlink         = ufs_unlink,
361         .symlink        = ufs_symlink,
362         .mkdir          = ufs_mkdir,
363         .rmdir          = ufs_rmdir,
364         .mknod          = ufs_mknod,
365         .rename         = ufs_rename,
366 };