fs/affs/namei.c

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