f3f3578393a417085812ba1ad7e0b7c1e4e5c981
[linux-2.6.git] / fs / minix / namei.c
1 /*
2  *  linux/fs/minix/namei.c
3  *
4  *  Copyright (C) 1991, 1992  Linus Torvalds
5  */
6
7 #include "minix.h"
8
9 static int add_nondir(struct dentry *dentry, struct inode *inode)
10 {
11         int err = minix_add_link(dentry, inode);
12         if (!err) {
13                 d_instantiate(dentry, inode);
14                 return 0;
15         }
16         inode_dec_link_count(inode);
17         iput(inode);
18         return err;
19 }
20
21 static struct dentry *minix_lookup(struct inode * dir, struct dentry *dentry, struct nameidata *nd)
22 {
23         struct inode * inode = NULL;
24         ino_t ino;
25
26         dentry->d_op = dir->i_sb->s_root->d_op;
27
28         if (dentry->d_name.len > minix_sb(dir->i_sb)->s_namelen)
29                 return ERR_PTR(-ENAMETOOLONG);
30
31         ino = minix_inode_by_name(dentry);
32         if (ino) {
33                 inode = minix_iget(dir->i_sb, ino);
34                 if (IS_ERR(inode))
35                         return ERR_CAST(inode);
36         }
37         d_add(dentry, inode);
38         return NULL;
39 }
40
41 static int minix_mknod(struct inode * dir, struct dentry *dentry, int mode, dev_t rdev)
42 {
43         int error;
44         struct inode *inode;
45
46         if (!old_valid_dev(rdev))
47                 return -EINVAL;
48
49         inode = minix_new_inode(dir, mode, &error);
50
51         if (inode) {
52                 minix_set_inode(inode, rdev);
53                 mark_inode_dirty(inode);
54                 error = add_nondir(dentry, inode);
55         }
56         return error;
57 }
58
59 static int minix_create(struct inode * dir, struct dentry *dentry, int mode,
60                 struct nameidata *nd)
61 {
62         return minix_mknod(dir, dentry, mode, 0);
63 }
64
65 static int minix_symlink(struct inode * dir, struct dentry *dentry,
66           const char * symname)
67 {
68         int err = -ENAMETOOLONG;
69         int i = strlen(symname)+1;
70         struct inode * inode;
71
72         if (i > dir->i_sb->s_blocksize)
73                 goto out;
74
75         inode = minix_new_inode(dir, S_IFLNK | 0777, &err);
76         if (!inode)
77                 goto out;
78
79         minix_set_inode(inode, 0);
80         err = page_symlink(inode, symname, i);
81         if (err)
82                 goto out_fail;
83
84         err = add_nondir(dentry, inode);
85 out:
86         return err;
87
88 out_fail:
89         inode_dec_link_count(inode);
90         iput(inode);
91         goto out;
92 }
93
94 static int minix_link(struct dentry * old_dentry, struct inode * dir,
95         struct dentry *dentry)
96 {
97         struct inode *inode = old_dentry->d_inode;
98
99         if (inode->i_nlink >= minix_sb(inode->i_sb)->s_link_max)
100                 return -EMLINK;
101
102         inode->i_ctime = CURRENT_TIME_SEC;
103         inode_inc_link_count(inode);
104         atomic_inc(&inode->i_count);
105         return add_nondir(dentry, inode);
106 }
107
108 static int minix_mkdir(struct inode * dir, struct dentry *dentry, int mode)
109 {
110         struct inode * inode;
111         int err = -EMLINK;
112
113         if (dir->i_nlink >= minix_sb(dir->i_sb)->s_link_max)
114                 goto out;
115
116         inode_inc_link_count(dir);
117
118         inode = minix_new_inode(dir, S_IFDIR | mode, &err);
119         if (!inode)
120                 goto out_dir;
121
122         minix_set_inode(inode, 0);
123
124         inode_inc_link_count(inode);
125
126         err = minix_make_empty(inode, dir);
127         if (err)
128                 goto out_fail;
129
130         err = minix_add_link(dentry, inode);
131         if (err)
132                 goto out_fail;
133
134         d_instantiate(dentry, inode);
135 out:
136         return err;
137
138 out_fail:
139         inode_dec_link_count(inode);
140         inode_dec_link_count(inode);
141         iput(inode);
142 out_dir:
143         inode_dec_link_count(dir);
144         goto out;
145 }
146
147 static int minix_unlink(struct inode * dir, struct dentry *dentry)
148 {
149         int err = -ENOENT;
150         struct inode * inode = dentry->d_inode;
151         struct page * page;
152         struct minix_dir_entry * de;
153
154         de = minix_find_entry(dentry, &page);
155         if (!de)
156                 goto end_unlink;
157
158         err = minix_delete_entry(de, page);
159         if (err)
160                 goto end_unlink;
161
162         inode->i_ctime = dir->i_ctime;
163         inode_dec_link_count(inode);
164 end_unlink:
165         return err;
166 }
167
168 static int minix_rmdir(struct inode * dir, struct dentry *dentry)
169 {
170         struct inode * inode = dentry->d_inode;
171         int err = -ENOTEMPTY;
172
173         if (minix_empty_dir(inode)) {
174                 err = minix_unlink(dir, dentry);
175                 if (!err) {
176                         inode_dec_link_count(dir);
177                         inode_dec_link_count(inode);
178                 }
179         }
180         return err;
181 }
182
183 static int minix_rename(struct inode * old_dir, struct dentry *old_dentry,
184                            struct inode * new_dir, struct dentry *new_dentry)
185 {
186         struct minix_sb_info * info = minix_sb(old_dir->i_sb);
187         struct inode * old_inode = old_dentry->d_inode;
188         struct inode * new_inode = new_dentry->d_inode;
189         struct page * dir_page = NULL;
190         struct minix_dir_entry * dir_de = NULL;
191         struct page * old_page;
192         struct minix_dir_entry * old_de;
193         int err = -ENOENT;
194
195         old_de = minix_find_entry(old_dentry, &old_page);
196         if (!old_de)
197                 goto out;
198
199         if (S_ISDIR(old_inode->i_mode)) {
200                 err = -EIO;
201                 dir_de = minix_dotdot(old_inode, &dir_page);
202                 if (!dir_de)
203                         goto out_old;
204         }
205
206         if (new_inode) {
207                 struct page * new_page;
208                 struct minix_dir_entry * new_de;
209
210                 err = -ENOTEMPTY;
211                 if (dir_de && !minix_empty_dir(new_inode))
212                         goto out_dir;
213
214                 err = -ENOENT;
215                 new_de = minix_find_entry(new_dentry, &new_page);
216                 if (!new_de)
217                         goto out_dir;
218                 inode_inc_link_count(old_inode);
219                 minix_set_link(new_de, new_page, old_inode);
220                 new_inode->i_ctime = CURRENT_TIME_SEC;
221                 if (dir_de)
222                         drop_nlink(new_inode);
223                 inode_dec_link_count(new_inode);
224         } else {
225                 if (dir_de) {
226                         err = -EMLINK;
227                         if (new_dir->i_nlink >= info->s_link_max)
228                                 goto out_dir;
229                 }
230                 inode_inc_link_count(old_inode);
231                 err = minix_add_link(new_dentry, old_inode);
232                 if (err) {
233                         inode_dec_link_count(old_inode);
234                         goto out_dir;
235                 }
236                 if (dir_de)
237                         inode_inc_link_count(new_dir);
238         }
239
240         minix_delete_entry(old_de, old_page);
241         inode_dec_link_count(old_inode);
242
243         if (dir_de) {
244                 minix_set_link(dir_de, dir_page, new_dir);
245                 inode_dec_link_count(old_dir);
246         }
247         return 0;
248
249 out_dir:
250         if (dir_de) {
251                 kunmap(dir_page);
252                 page_cache_release(dir_page);
253         }
254 out_old:
255         kunmap(old_page);
256         page_cache_release(old_page);
257 out:
258         return err;
259 }
260
261 /*
262  * directories can handle most operations...
263  */
264 const struct inode_operations minix_dir_inode_operations = {
265         .create         = minix_create,
266         .lookup         = minix_lookup,
267         .link           = minix_link,
268         .unlink         = minix_unlink,
269         .symlink        = minix_symlink,
270         .mkdir          = minix_mkdir,
271         .rmdir          = minix_rmdir,
272         .mknod          = minix_mknod,
273         .rename         = minix_rename,
274         .getattr        = minix_getattr,
275 };