2 * linux/fs/affs/namei.c
4 * (c) 1996 Hans-Joachim Widmaier - Rewritten
6 * (C) 1993 Ray Burr - Modified for Amiga FFS filesystem.
8 * (C) 1991 Linus Torvalds - minix filesystem
13 typedef int (*toupper_t)(int);
15 static int affs_toupper(int ch);
16 static int affs_hash_dentry(const struct dentry *,
17 const struct inode *, struct qstr *);
18 static int affs_compare_dentry(const struct dentry *parent,
19 const struct inode *pinode,
20 const struct dentry *dentry, const struct inode *inode,
21 unsigned int len, const char *str, const struct qstr *name);
22 static int affs_intl_toupper(int ch);
23 static int affs_intl_hash_dentry(const struct dentry *,
24 const struct inode *, struct qstr *);
25 static int affs_intl_compare_dentry(const struct dentry *parent,
26 const struct inode *pinode,
27 const struct dentry *dentry, const struct inode *inode,
28 unsigned int len, const char *str, const struct qstr *name);
30 const struct dentry_operations affs_dentry_operations = {
31 .d_hash = affs_hash_dentry,
32 .d_compare = affs_compare_dentry,
35 const struct dentry_operations affs_intl_dentry_operations = {
36 .d_hash = affs_intl_hash_dentry,
37 .d_compare = affs_intl_compare_dentry,
41 /* Simple toupper() for DOS\1 */
46 return ch >= 'a' && ch <= 'z' ? ch -= ('a' - 'A') : ch;
49 /* International toupper() for DOS\3 ("international") */
52 affs_intl_toupper(int ch)
54 return (ch >= 'a' && ch <= 'z') || (ch >= 0xE0
55 && ch <= 0xFE && ch != 0xF7) ?
56 ch - ('a' - 'A') : ch;
59 static inline toupper_t
60 affs_get_toupper(struct super_block *sb)
62 return AFFS_SB(sb)->s_flags & SF_INTL ? affs_intl_toupper : affs_toupper;
66 * Note: the dentry argument is the parent dentry.
69 __affs_hash_dentry(struct qstr *qstr, toupper_t toupper)
71 const u8 *name = qstr->name;
75 i = affs_check_name(qstr->name, qstr->len);
79 hash = init_name_hash();
80 i = min(qstr->len, 30u);
81 for (; i > 0; name++, i--)
82 hash = partial_name_hash(toupper(*name), hash);
83 qstr->hash = end_name_hash(hash);
89 affs_hash_dentry(const struct dentry *dentry, const struct inode *inode,
92 return __affs_hash_dentry(qstr, affs_toupper);
95 affs_intl_hash_dentry(const struct dentry *dentry, const struct inode *inode,
98 return __affs_hash_dentry(qstr, affs_intl_toupper);
101 static inline int __affs_compare_dentry(unsigned int len,
102 const char *str, const struct qstr *name, toupper_t toupper)
104 const u8 *aname = str;
105 const u8 *bname = name->name;
108 * 'str' is the name of an already existing dentry, so the name
109 * must be valid. 'name' must be validated first.
112 if (affs_check_name(name->name, name->len))
116 * If the names are longer than the allowed 30 chars,
117 * the excess is ignored, so their length may differ.
123 } else if (len != name->len)
126 for (; len > 0; len--)
127 if (toupper(*aname++) != toupper(*bname++))
134 affs_compare_dentry(const struct dentry *parent, const struct inode *pinode,
135 const struct dentry *dentry, const struct inode *inode,
136 unsigned int len, const char *str, const struct qstr *name)
138 return __affs_compare_dentry(len, str, name, affs_toupper);
141 affs_intl_compare_dentry(const struct dentry *parent,const struct inode *pinode,
142 const struct dentry *dentry, const struct inode *inode,
143 unsigned int len, const char *str, const struct qstr *name)
145 return __affs_compare_dentry(len, str, name, affs_intl_toupper);
149 * NOTE! unlike strncmp, affs_match returns 1 for success, 0 for failure.
153 affs_match(struct dentry *dentry, const u8 *name2, toupper_t toupper)
155 const u8 *name = dentry->d_name.name;
156 int len = dentry->d_name.len;
162 } else if (len != *name2)
165 for (name2++; len > 0; len--)
166 if (toupper(*name++) != toupper(*name2++))
172 affs_hash_name(struct super_block *sb, const u8 *name, unsigned int len)
174 toupper_t toupper = affs_get_toupper(sb);
177 hash = len = min(len, 30u);
178 for (; len > 0; len--)
179 hash = (hash * 13 + toupper(*name++)) & 0x7ff;
181 return hash % AFFS_SB(sb)->s_hashsize;
184 static struct buffer_head *
185 affs_find_entry(struct inode *dir, struct dentry *dentry)
187 struct super_block *sb = dir->i_sb;
188 struct buffer_head *bh;
189 toupper_t toupper = affs_get_toupper(sb);
192 pr_debug("AFFS: find_entry(\"%.*s\")\n", (int)dentry->d_name.len, dentry->d_name.name);
194 bh = affs_bread(sb, dir->i_ino);
196 return ERR_PTR(-EIO);
198 key = be32_to_cpu(AFFS_HEAD(bh)->table[affs_hash_name(sb, dentry->d_name.name, dentry->d_name.len)]);
204 bh = affs_bread(sb, key);
206 return ERR_PTR(-EIO);
207 if (affs_match(dentry, AFFS_TAIL(sb, bh)->name, toupper))
209 key = be32_to_cpu(AFFS_TAIL(sb, bh)->hash_chain);
214 affs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
216 struct super_block *sb = dir->i_sb;
217 struct buffer_head *bh;
218 struct inode *inode = NULL;
220 pr_debug("AFFS: lookup(\"%.*s\")\n",(int)dentry->d_name.len,dentry->d_name.name);
223 bh = affs_find_entry(dir, dentry);
224 affs_unlock_dir(dir);
228 u32 ino = bh->b_blocknr;
230 /* store the real header ino in d_fsdata for faster lookups */
231 dentry->d_fsdata = (void *)(long)ino;
232 switch (be32_to_cpu(AFFS_TAIL(sb, bh)->stype)) {
233 //link to dirs disabled
236 ino = be32_to_cpu(AFFS_TAIL(sb, bh)->original);
239 inode = affs_iget(sb, ino);
241 return ERR_CAST(inode);
243 d_add(dentry, inode);
248 affs_unlink(struct inode *dir, struct dentry *dentry)
250 pr_debug("AFFS: unlink(dir=%d, %lu \"%.*s\")\n", (u32)dir->i_ino,
251 dentry->d_inode->i_ino,
252 (int)dentry->d_name.len, dentry->d_name.name);
254 return affs_remove_header(dentry);
258 affs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
260 struct super_block *sb = dir->i_sb;
264 pr_debug("AFFS: create(%lu,\"%.*s\",0%o)\n",dir->i_ino,(int)dentry->d_name.len,
265 dentry->d_name.name,mode);
267 inode = affs_new_inode(dir);
271 inode->i_mode = mode;
273 mark_inode_dirty(inode);
275 inode->i_op = &affs_file_inode_operations;
276 inode->i_fop = &affs_file_operations;
277 inode->i_mapping->a_ops = (AFFS_SB(sb)->s_flags & SF_OFS) ? &affs_aops_ofs : &affs_aops;
278 error = affs_add_entry(dir, inode, dentry, ST_FILE);
288 affs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
293 pr_debug("AFFS: mkdir(%lu,\"%.*s\",0%o)\n",dir->i_ino,
294 (int)dentry->d_name.len,dentry->d_name.name,mode);
296 inode = affs_new_inode(dir);
300 inode->i_mode = S_IFDIR | mode;
303 inode->i_op = &affs_dir_inode_operations;
304 inode->i_fop = &affs_dir_operations;
306 error = affs_add_entry(dir, inode, dentry, ST_USERDIR);
309 mark_inode_dirty(inode);
317 affs_rmdir(struct inode *dir, struct dentry *dentry)
319 pr_debug("AFFS: rmdir(dir=%u, %lu \"%.*s\")\n", (u32)dir->i_ino,
320 dentry->d_inode->i_ino,
321 (int)dentry->d_name.len, dentry->d_name.name);
323 dentry_unhash(dentry);
325 return affs_remove_header(dentry);
329 affs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
331 struct super_block *sb = dir->i_sb;
332 struct buffer_head *bh;
335 int i, maxlen, error;
338 pr_debug("AFFS: symlink(%lu,\"%.*s\" -> \"%s\")\n",dir->i_ino,
339 (int)dentry->d_name.len,dentry->d_name.name,symname);
341 maxlen = AFFS_SB(sb)->s_hashsize * sizeof(u32) - 1;
342 inode = affs_new_inode(dir);
346 inode->i_op = &affs_symlink_inode_operations;
347 inode->i_data.a_ops = &affs_symlink_aops;
348 inode->i_mode = S_IFLNK | 0777;
352 bh = affs_bread(sb, inode->i_ino);
356 p = (char *)AFFS_HEAD(bh)->table;
358 if (*symname == '/') {
359 struct affs_sb_info *sbi = AFFS_SB(sb);
360 while (*symname == '/')
362 spin_lock(&sbi->symlink_lock);
363 while (sbi->s_volume[i]) /* Cannot overflow */
364 *p++ = sbi->s_volume[i++];
365 spin_unlock(&sbi->symlink_lock);
367 while (i < maxlen && (c = *symname++)) {
368 if (c == '.' && lc == '/' && *symname == '.' && symname[1] == '/') {
373 } else if (c == '.' && lc == '/' && *symname == '/') {
382 while (*symname == '/')
386 mark_buffer_dirty_inode(bh, inode);
388 mark_inode_dirty(inode);
390 error = affs_add_entry(dir, inode, dentry, ST_SOFTLINK);
398 mark_inode_dirty(inode);
404 affs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
406 struct inode *inode = old_dentry->d_inode;
408 pr_debug("AFFS: link(%u, %u, \"%.*s\")\n", (u32)inode->i_ino, (u32)dir->i_ino,
409 (int)dentry->d_name.len,dentry->d_name.name);
411 return affs_add_entry(dir, inode, dentry, ST_LINKFILE);
415 affs_rename(struct inode *old_dir, struct dentry *old_dentry,
416 struct inode *new_dir, struct dentry *new_dentry)
418 struct super_block *sb = old_dir->i_sb;
419 struct buffer_head *bh = NULL;
422 pr_debug("AFFS: rename(old=%u,\"%*s\" to new=%u,\"%*s\")\n",
423 (u32)old_dir->i_ino, (int)old_dentry->d_name.len, old_dentry->d_name.name,
424 (u32)new_dir->i_ino, (int)new_dentry->d_name.len, new_dentry->d_name.name);
426 retval = affs_check_name(new_dentry->d_name.name,new_dentry->d_name.len);
430 /* Unlink destination if it already exists */
431 if (new_dentry->d_inode) {
432 retval = affs_remove_header(new_dentry);
437 bh = affs_bread(sb, old_dentry->d_inode->i_ino);
441 /* Remove header from its parent directory. */
442 affs_lock_dir(old_dir);
443 retval = affs_remove_hash(old_dir, bh);
444 affs_unlock_dir(old_dir);
448 /* And insert it into the new directory with the new name. */
449 affs_copy_name(AFFS_TAIL(sb, bh)->name, new_dentry);
450 affs_fix_checksum(sb, bh);
451 affs_lock_dir(new_dir);
452 retval = affs_insert_hash(new_dir, bh);
453 affs_unlock_dir(new_dir);
454 /* TODO: move it back to old_dir, if error? */
457 mark_buffer_dirty_inode(bh, retval ? old_dir : new_dir);