blob: d70bbbac6b7be31709f407f081672d0d6893fda5 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/affs/namei.c
3 *
4 * (c) 1996 Hans-Joachim Widmaier - Rewritten
5 *
6 * (C) 1993 Ray Burr - Modified for Amiga FFS filesystem.
7 *
8 * (C) 1991 Linus Torvalds - minix filesystem
9 */
10
11#include "affs.h"
12
13typedef int (*toupper_t)(int);
14
15static int affs_toupper(int ch);
16static int affs_hash_dentry(struct dentry *, struct qstr *);
17static int affs_compare_dentry(struct dentry *, struct qstr *, struct qstr *);
18static int affs_intl_toupper(int ch);
19static int affs_intl_hash_dentry(struct dentry *, struct qstr *);
20static int affs_intl_compare_dentry(struct dentry *, struct qstr *, struct qstr *);
21
Al Viroe16404e2009-02-20 05:55:13 +000022const struct dentry_operations affs_dentry_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070023 .d_hash = affs_hash_dentry,
24 .d_compare = affs_compare_dentry,
25};
26
Al Viroe16404e2009-02-20 05:55:13 +000027static const struct dentry_operations affs_intl_dentry_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070028 .d_hash = affs_intl_hash_dentry,
29 .d_compare = affs_intl_compare_dentry,
30};
31
32
33/* Simple toupper() for DOS\1 */
34
35static int
36affs_toupper(int ch)
37{
38 return ch >= 'a' && ch <= 'z' ? ch -= ('a' - 'A') : ch;
39}
40
41/* International toupper() for DOS\3 ("international") */
42
43static int
44affs_intl_toupper(int ch)
45{
46 return (ch >= 'a' && ch <= 'z') || (ch >= 0xE0
47 && ch <= 0xFE && ch != 0xF7) ?
48 ch - ('a' - 'A') : ch;
49}
50
51static inline toupper_t
52affs_get_toupper(struct super_block *sb)
53{
54 return AFFS_SB(sb)->s_flags & SF_INTL ? affs_intl_toupper : affs_toupper;
55}
56
57/*
58 * Note: the dentry argument is the parent dentry.
59 */
60static inline int
61__affs_hash_dentry(struct dentry *dentry, struct qstr *qstr, toupper_t toupper)
62{
63 const u8 *name = qstr->name;
64 unsigned long hash;
65 int i;
66
67 i = affs_check_name(qstr->name,qstr->len);
68 if (i)
69 return i;
70
71 hash = init_name_hash();
72 i = min(qstr->len, 30u);
73 for (; i > 0; name++, i--)
74 hash = partial_name_hash(toupper(*name), hash);
75 qstr->hash = end_name_hash(hash);
76
77 return 0;
78}
79
80static int
81affs_hash_dentry(struct dentry *dentry, struct qstr *qstr)
82{
83 return __affs_hash_dentry(dentry, qstr, affs_toupper);
84}
85static int
86affs_intl_hash_dentry(struct dentry *dentry, struct qstr *qstr)
87{
88 return __affs_hash_dentry(dentry, qstr, affs_intl_toupper);
89}
90
91static inline int
92__affs_compare_dentry(struct dentry *dentry, struct qstr *a, struct qstr *b, toupper_t toupper)
93{
94 const u8 *aname = a->name;
95 const u8 *bname = b->name;
96 int len;
97
98 /* 'a' is the qstr of an already existing dentry, so the name
99 * must be valid. 'b' must be validated first.
100 */
101
102 if (affs_check_name(b->name,b->len))
103 return 1;
104
105 /* If the names are longer than the allowed 30 chars,
106 * the excess is ignored, so their length may differ.
107 */
108 len = a->len;
109 if (len >= 30) {
110 if (b->len < 30)
111 return 1;
112 len = 30;
113 } else if (len != b->len)
114 return 1;
115
116 for (; len > 0; len--)
117 if (toupper(*aname++) != toupper(*bname++))
118 return 1;
119
120 return 0;
121}
122
123static int
124affs_compare_dentry(struct dentry *dentry, struct qstr *a, struct qstr *b)
125{
126 return __affs_compare_dentry(dentry, a, b, affs_toupper);
127}
128static int
129affs_intl_compare_dentry(struct dentry *dentry, struct qstr *a, struct qstr *b)
130{
131 return __affs_compare_dentry(dentry, a, b, affs_intl_toupper);
132}
133
134/*
135 * NOTE! unlike strncmp, affs_match returns 1 for success, 0 for failure.
136 */
137
138static inline int
139affs_match(struct dentry *dentry, const u8 *name2, toupper_t toupper)
140{
141 const u8 *name = dentry->d_name.name;
142 int len = dentry->d_name.len;
143
144 if (len >= 30) {
145 if (*name2 < 30)
146 return 0;
147 len = 30;
148 } else if (len != *name2)
149 return 0;
150
151 for (name2++; len > 0; len--)
152 if (toupper(*name++) != toupper(*name2++))
153 return 0;
154 return 1;
155}
156
157int
158affs_hash_name(struct super_block *sb, const u8 *name, unsigned int len)
159{
160 toupper_t toupper = affs_get_toupper(sb);
161 int hash;
162
163 hash = len = min(len, 30u);
164 for (; len > 0; len--)
165 hash = (hash * 13 + toupper(*name++)) & 0x7ff;
166
167 return hash % AFFS_SB(sb)->s_hashsize;
168}
169
170static struct buffer_head *
171affs_find_entry(struct inode *dir, struct dentry *dentry)
172{
173 struct super_block *sb = dir->i_sb;
174 struct buffer_head *bh;
175 toupper_t toupper = affs_get_toupper(sb);
176 u32 key;
177
178 pr_debug("AFFS: find_entry(\"%.*s\")\n", (int)dentry->d_name.len, dentry->d_name.name);
179
180 bh = affs_bread(sb, dir->i_ino);
181 if (!bh)
182 return ERR_PTR(-EIO);
183
184 key = be32_to_cpu(AFFS_HEAD(bh)->table[affs_hash_name(sb, dentry->d_name.name, dentry->d_name.len)]);
185
186 for (;;) {
187 affs_brelse(bh);
188 if (key == 0)
189 return NULL;
190 bh = affs_bread(sb, key);
191 if (!bh)
192 return ERR_PTR(-EIO);
193 if (affs_match(dentry, AFFS_TAIL(sb, bh)->name, toupper))
194 return bh;
195 key = be32_to_cpu(AFFS_TAIL(sb, bh)->hash_chain);
196 }
197}
198
199struct dentry *
200affs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
201{
202 struct super_block *sb = dir->i_sb;
203 struct buffer_head *bh;
204 struct inode *inode = NULL;
205
206 pr_debug("AFFS: lookup(\"%.*s\")\n",(int)dentry->d_name.len,dentry->d_name.name);
207
208 affs_lock_dir(dir);
209 bh = affs_find_entry(dir, dentry);
210 affs_unlock_dir(dir);
David Howells210f8552008-02-07 00:15:29 -0800211 if (IS_ERR(bh))
David Howellse231c2e2008-02-07 00:15:26 -0800212 return ERR_CAST(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 if (bh) {
214 u32 ino = bh->b_blocknr;
215
216 /* store the real header ino in d_fsdata for faster lookups */
217 dentry->d_fsdata = (void *)(long)ino;
218 switch (be32_to_cpu(AFFS_TAIL(sb, bh)->stype)) {
219 //link to dirs disabled
220 //case ST_LINKDIR:
221 case ST_LINKFILE:
222 ino = be32_to_cpu(AFFS_TAIL(sb, bh)->original);
223 }
224 affs_brelse(bh);
David Howells210f8552008-02-07 00:15:29 -0800225 inode = affs_iget(sb, ino);
226 if (IS_ERR(inode))
227 return ERR_PTR(PTR_ERR(inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 }
229 dentry->d_op = AFFS_SB(sb)->s_flags & SF_INTL ? &affs_intl_dentry_operations : &affs_dentry_operations;
230 d_add(dentry, inode);
231 return NULL;
232}
233
234int
235affs_unlink(struct inode *dir, struct dentry *dentry)
236{
Roman Zippeldca3c332008-04-29 17:02:20 +0200237 pr_debug("AFFS: unlink(dir=%d, %lu \"%.*s\")\n", (u32)dir->i_ino,
238 dentry->d_inode->i_ino,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 (int)dentry->d_name.len, dentry->d_name.name);
240
241 return affs_remove_header(dentry);
242}
243
244int
245affs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
246{
247 struct super_block *sb = dir->i_sb;
248 struct inode *inode;
249 int error;
250
251 pr_debug("AFFS: create(%lu,\"%.*s\",0%o)\n",dir->i_ino,(int)dentry->d_name.len,
252 dentry->d_name.name,mode);
253
254 inode = affs_new_inode(dir);
255 if (!inode)
256 return -ENOSPC;
257
258 inode->i_mode = mode;
259 mode_to_prot(inode);
260 mark_inode_dirty(inode);
261
262 inode->i_op = &affs_file_inode_operations;
263 inode->i_fop = &affs_file_operations;
264 inode->i_mapping->a_ops = (AFFS_SB(sb)->s_flags & SF_OFS) ? &affs_aops_ofs : &affs_aops;
265 error = affs_add_entry(dir, inode, dentry, ST_FILE);
266 if (error) {
267 inode->i_nlink = 0;
268 iput(inode);
269 return error;
270 }
271 return 0;
272}
273
274int
275affs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
276{
277 struct inode *inode;
278 int error;
279
280 pr_debug("AFFS: mkdir(%lu,\"%.*s\",0%o)\n",dir->i_ino,
281 (int)dentry->d_name.len,dentry->d_name.name,mode);
282
283 inode = affs_new_inode(dir);
284 if (!inode)
285 return -ENOSPC;
286
287 inode->i_mode = S_IFDIR | mode;
288 mode_to_prot(inode);
289
290 inode->i_op = &affs_dir_inode_operations;
291 inode->i_fop = &affs_dir_operations;
292
293 error = affs_add_entry(dir, inode, dentry, ST_USERDIR);
294 if (error) {
295 inode->i_nlink = 0;
296 mark_inode_dirty(inode);
297 iput(inode);
298 return error;
299 }
300 return 0;
301}
302
303int
304affs_rmdir(struct inode *dir, struct dentry *dentry)
305{
Roman Zippeldca3c332008-04-29 17:02:20 +0200306 pr_debug("AFFS: rmdir(dir=%u, %lu \"%.*s\")\n", (u32)dir->i_ino,
307 dentry->d_inode->i_ino,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 (int)dentry->d_name.len, dentry->d_name.name);
309
310 return affs_remove_header(dentry);
311}
312
313int
314affs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
315{
316 struct super_block *sb = dir->i_sb;
317 struct buffer_head *bh;
318 struct inode *inode;
319 char *p;
320 int i, maxlen, error;
321 char c, lc;
322
323 pr_debug("AFFS: symlink(%lu,\"%.*s\" -> \"%s\")\n",dir->i_ino,
324 (int)dentry->d_name.len,dentry->d_name.name,symname);
325
326 maxlen = AFFS_SB(sb)->s_hashsize * sizeof(u32) - 1;
327 inode = affs_new_inode(dir);
328 if (!inode)
329 return -ENOSPC;
330
331 inode->i_op = &affs_symlink_inode_operations;
332 inode->i_data.a_ops = &affs_symlink_aops;
333 inode->i_mode = S_IFLNK | 0777;
334 mode_to_prot(inode);
335
336 error = -EIO;
337 bh = affs_bread(sb, inode->i_ino);
338 if (!bh)
339 goto err;
340 i = 0;
341 p = (char *)AFFS_HEAD(bh)->table;
342 lc = '/';
343 if (*symname == '/') {
Al Viro29333922010-01-24 00:04:07 -0500344 struct affs_sb_info *sbi = AFFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 while (*symname == '/')
346 symname++;
Al Viro29333922010-01-24 00:04:07 -0500347 spin_lock(&sbi->symlink_lock);
348 while (sbi->s_volume[i]) /* Cannot overflow */
349 *p++ = sbi->s_volume[i++];
350 spin_unlock(&sbi->symlink_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 }
352 while (i < maxlen && (c = *symname++)) {
353 if (c == '.' && lc == '/' && *symname == '.' && symname[1] == '/') {
354 *p++ = '/';
355 i++;
356 symname += 2;
357 lc = '/';
358 } else if (c == '.' && lc == '/' && *symname == '/') {
359 symname++;
360 lc = '/';
361 } else {
362 *p++ = c;
363 lc = c;
364 i++;
365 }
366 if (lc == '/')
367 while (*symname == '/')
368 symname++;
369 }
370 *p = 0;
371 mark_buffer_dirty_inode(bh, inode);
372 affs_brelse(bh);
373 mark_inode_dirty(inode);
374
375 error = affs_add_entry(dir, inode, dentry, ST_SOFTLINK);
376 if (error)
377 goto err;
378
379 return 0;
380
381err:
382 inode->i_nlink = 0;
383 mark_inode_dirty(inode);
384 iput(inode);
385 return error;
386}
387
388int
389affs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
390{
391 struct inode *inode = old_dentry->d_inode;
392
393 pr_debug("AFFS: link(%u, %u, \"%.*s\")\n", (u32)inode->i_ino, (u32)dir->i_ino,
394 (int)dentry->d_name.len,dentry->d_name.name);
395
396 return affs_add_entry(dir, inode, dentry, ST_LINKFILE);
397}
398
399int
400affs_rename(struct inode *old_dir, struct dentry *old_dentry,
401 struct inode *new_dir, struct dentry *new_dentry)
402{
403 struct super_block *sb = old_dir->i_sb;
404 struct buffer_head *bh = NULL;
405 int retval;
406
407 pr_debug("AFFS: rename(old=%u,\"%*s\" to new=%u,\"%*s\")\n",
408 (u32)old_dir->i_ino, (int)old_dentry->d_name.len, old_dentry->d_name.name,
409 (u32)new_dir->i_ino, (int)new_dentry->d_name.len, new_dentry->d_name.name);
410
411 retval = affs_check_name(new_dentry->d_name.name,new_dentry->d_name.len);
412 if (retval)
413 return retval;
414
415 /* Unlink destination if it already exists */
416 if (new_dentry->d_inode) {
417 retval = affs_remove_header(new_dentry);
418 if (retval)
419 return retval;
420 }
421
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 bh = affs_bread(sb, old_dentry->d_inode->i_ino);
423 if (!bh)
Florin Malita3ac81412006-05-25 18:44:23 -0700424 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425
426 /* Remove header from its parent directory. */
427 affs_lock_dir(old_dir);
428 retval = affs_remove_hash(old_dir, bh);
429 affs_unlock_dir(old_dir);
430 if (retval)
431 goto done;
432
433 /* And insert it into the new directory with the new name. */
434 affs_copy_name(AFFS_TAIL(sb, bh)->name, new_dentry);
435 affs_fix_checksum(sb, bh);
436 affs_lock_dir(new_dir);
437 retval = affs_insert_hash(new_dir, bh);
438 affs_unlock_dir(new_dir);
439 /* TODO: move it back to old_dir, if error? */
440
441done:
442 mark_buffer_dirty_inode(bh, retval ? old_dir : new_dir);
443 affs_brelse(bh);
444 return retval;
445}