fs/hfsplus/dir.c

   1 /*
   2  *  linux/fs/hfsplus/dir.c
   3  *
   4  * Copyright (C) 2001
   5  * Brad Boyer (flar@allandria.com)
   6  * (C) 2003 Ardis Technologies <roman@ardistech.com>
   7  *
   8  * Handling of directories
   9  */
  10
  11 #include <linux/errno.h>
  12 #include <linux/fs.h>
  13 #include <linux/slab.h>
  14 #include <linux/random.h>
  15
  16 #include "hfsplus_fs.h"
  17 #include "hfsplus_raw.h"
  18 #include "xattr.h"
  19
  20 static inline void hfsplus_instantiate(struct dentry *dentry,
  21                                        struct inode *inode, u32 cnid)
  22 {
  23         dentry->d_fsdata = (void *)(unsigned long)cnid;
  24         d_instantiate(dentry, inode);
  25 }
  26
  27 /* Find the entry inside dir named dentry->d_name */
  28 static struct dentry *hfsplus_lookup(struct inode *dir, struct dentry *dentry,
  29                                      unsigned int flags)
  30 {
  31         struct inode *inode = NULL;
  32         struct hfs_find_data fd;
  33         struct super_block *sb;
  34         hfsplus_cat_entry entry;
  35         int err;
  36         u32 cnid, linkid = 0;
  37         u16 type;
  38
  39         sb = dir->i_sb;
  40
  41         dentry->d_fsdata = NULL;
  42         err = hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd);
  43         if (err)
  44                 return ERR_PTR(err);
  45         hfsplus_cat_build_key(sb, fd.search_key, dir->i_ino, &dentry->d_name);
  46 again:
  47         err = hfs_brec_read(&fd, &entry, sizeof(entry));
  48         if (err) {
  49                 if (err == -ENOENT) {
  50                         hfs_find_exit(&fd);
  51                         /* No such entry */
  52                         inode = NULL;
  53                         goto out;
  54                 }
  55                 goto fail;
  56         }
  57         type = be16_to_cpu(entry.type);
  58         if (type == HFSPLUS_FOLDER) {
  59                 if (fd.entrylength < sizeof(struct hfsplus_cat_folder)) {
  60                         err = -EIO;
  61                         goto fail;
  62                 }
  63                 cnid = be32_to_cpu(entry.folder.id);
  64                 dentry->d_fsdata = (void *)(unsigned long)cnid;
  65         } else if (type == HFSPLUS_FILE) {
  66                 if (fd.entrylength < sizeof(struct hfsplus_cat_file)) {
  67                         err = -EIO;
  68                         goto fail;
  69                 }
  70                 cnid = be32_to_cpu(entry.file.id);
  71                 if (entry.file.user_info.fdType ==
  72                                 cpu_to_be32(HFSP_HARDLINK_TYPE) &&
  73                                 entry.file.user_info.fdCreator ==
  74                                 cpu_to_be32(HFSP_HFSPLUS_CREATOR) &&
  75                                 (entry.file.create_date ==
  76                                         HFSPLUS_I(HFSPLUS_SB(sb)->hidden_dir)->
  77                                                 create_date ||
  78                                 entry.file.create_date ==
  79                                         HFSPLUS_I(sb->s_root->d_inode)->
  80                                                 create_date) &&
  81                                 HFSPLUS_SB(sb)->hidden_dir) {
  82                         struct qstr str;
  83                         char name[32];
  84
  85                         if (dentry->d_fsdata) {
  86                                 /*
  87                                  * We found a link pointing to another link,
  88                                  * so ignore it and treat it as regular file.
  89                                  */
  90                                 cnid = (unsigned long)dentry->d_fsdata;
  91                                 linkid = 0;
  92                         } else {
  93                                 dentry->d_fsdata = (void *)(unsigned long)cnid;
  94                                 linkid =
  95                                         be32_to_cpu(entry.file.permissions.dev);
  96                                 str.len = sprintf(name, "iNode%d", linkid);
  97                                 str.name = name;
  98                                 hfsplus_cat_build_key(sb, fd.search_key,
  99                                         HFSPLUS_SB(sb)->hidden_dir->i_ino,
 100                                         &str);
 101                                 goto again;
 102                         }
 103                 } else if (!dentry->d_fsdata)
 104                         dentry->d_fsdata = (void *)(unsigned long)cnid;
 105         } else {
 106                 printk(KERN_ERR "hfs: invalid catalog entry type in lookup\n");
 107                 err = -EIO;
 108                 goto fail;
 109         }
 110         hfs_find_exit(&fd);
 111         inode = hfsplus_iget(dir->i_sb, cnid);
 112         if (IS_ERR(inode))
 113                 return ERR_CAST(inode);
 114         if (S_ISREG(inode->i_mode))
 115                 HFSPLUS_I(inode)->linkid = linkid;
 116 out:
 117         d_add(dentry, inode);
 118         return NULL;
 119 fail:
 120         hfs_find_exit(&fd);
 121         return ERR_PTR(err);
 122 }
 123
 124 static int hfsplus_readdir(struct file *filp, void *dirent, filldir_t filldir)
 125 {
 126         struct inode *inode = file_inode(filp);
 127         struct super_block *sb = inode->i_sb;
 128         int len, err;
 129         char strbuf[HFSPLUS_MAX_STRLEN + 1];
 130         hfsplus_cat_entry entry;
 131         struct hfs_find_data fd;
 132         struct hfsplus_readdir_data *rd;
 133         u16 type;
 134
 135         if (filp->f_pos >= inode->i_size)
 136                 return 0;
 137
 138         err = hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd);
 139         if (err)
 140                 return err;
 141         hfsplus_cat_build_key(sb, fd.search_key, inode->i_ino, NULL);
 142         err = hfs_brec_find(&fd, hfs_find_rec_by_key);
 143         if (err)
 144                 goto out;
 145
 146         switch ((u32)filp->f_pos) {
 147         case 0:
 148                 /* This is completely artificial... */
 149                 if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR))
 150                         goto out;
 151                 filp->f_pos++;
 152                 /* fall through */
 153         case 1:
 154                 if (fd.entrylength > sizeof(entry) || fd.entrylength < 0) {
 155                         err = -EIO;
 156                         goto out;
 157                 }
 158
 159                 hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
 160                         fd.entrylength);
 161                 if (be16_to_cpu(entry.type) != HFSPLUS_FOLDER_THREAD) {
 162                         printk(KERN_ERR "hfs: bad catalog folder thread\n");
 163                         err = -EIO;
 164                         goto out;
 165                 }
 166                 if (fd.entrylength < HFSPLUS_MIN_THREAD_SZ) {
 167                         printk(KERN_ERR "hfs: truncated catalog thread\n");
 168                         err = -EIO;
 169                         goto out;
 170                 }
 171                 if (filldir(dirent, "..", 2, 1,
 172                             be32_to_cpu(entry.thread.parentID), DT_DIR))
 173                         goto out;
 174                 filp->f_pos++;
 175                 /* fall through */
 176         default:
 177                 if (filp->f_pos >= inode->i_size)
 178                         goto out;
 179                 err = hfs_brec_goto(&fd, filp->f_pos - 1);
 180                 if (err)
 181                         goto out;
 182         }
 183
 184         for (;;) {
 185                 if (be32_to_cpu(fd.key->cat.parent) != inode->i_ino) {
 186                         printk(KERN_ERR "hfs: walked past end of dir\n");
 187                         err = -EIO;
 188                         goto out;
 189                 }
 190
 191                 if (fd.entrylength > sizeof(entry) || fd.entrylength < 0) {
 192                         err = -EIO;
 193                         goto out;
 194                 }
 195
 196                 hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
 197                         fd.entrylength);
 198                 type = be16_to_cpu(entry.type);
 199                 len = HFSPLUS_MAX_STRLEN;
 200                 err = hfsplus_uni2asc(sb, &fd.key->cat.name, strbuf, &len);
 201                 if (err)
 202                         goto out;
 203                 if (type == HFSPLUS_FOLDER) {
 204                         if (fd.entrylength <
 205                                         sizeof(struct hfsplus_cat_folder)) {
 206                                 printk(KERN_ERR "hfs: small dir entry\n");
 207                                 err = -EIO;
 208                                 goto out;
 209                         }
 210                         if (HFSPLUS_SB(sb)->hidden_dir &&
 211                             HFSPLUS_SB(sb)->hidden_dir->i_ino ==
 212                                         be32_to_cpu(entry.folder.id))
 213                                 goto next;
 214                         if (filldir(dirent, strbuf, len, filp->f_pos,
 215                                     be32_to_cpu(entry.folder.id), DT_DIR))
 216                                 break;
 217                 } else if (type == HFSPLUS_FILE) {
 218                         if (fd.entrylength < sizeof(struct hfsplus_cat_file)) {
 219                                 printk(KERN_ERR "hfs: small file entry\n");
 220                                 err = -EIO;
 221                                 goto out;
 222                         }
 223                         if (filldir(dirent, strbuf, len, filp->f_pos,
 224                                     be32_to_cpu(entry.file.id), DT_REG))
 225                                 break;
 226                 } else {
 227                         printk(KERN_ERR "hfs: bad catalog entry type\n");
 228                         err = -EIO;
 229                         goto out;
 230                 }
 231 next:
 232                 filp->f_pos++;
 233                 if (filp->f_pos >= inode->i_size)
 234                         goto out;
 235                 err = hfs_brec_goto(&fd, 1);
 236                 if (err)
 237                         goto out;
 238         }
 239         rd = filp->private_data;
 240         if (!rd) {
 241                 rd = kmalloc(sizeof(struct hfsplus_readdir_data), GFP_KERNEL);
 242                 if (!rd) {
 243                         err = -ENOMEM;
 244                         goto out;
 245                 }
 246                 filp->private_data = rd;
 247                 rd->file = filp;
 248                 list_add(&rd->list, &HFSPLUS_I(inode)->open_dir_list);
 249         }
 250         memcpy(&rd->key, fd.key, sizeof(struct hfsplus_cat_key));
 251 out:
 252         hfs_find_exit(&fd);
 253         return err;
 254 }
 255
 256 static int hfsplus_dir_release(struct inode *inode, struct file *file)
 257 {
 258         struct hfsplus_readdir_data *rd = file->private_data;
 259         if (rd) {
 260                 mutex_lock(&inode->i_mutex);
 261                 list_del(&rd->list);
 262                 mutex_unlock(&inode->i_mutex);
 263                 kfree(rd);
 264         }
 265         return 0;
 266 }
 267
 268 static int hfsplus_link(struct dentry *src_dentry, struct inode *dst_dir,
 269                         struct dentry *dst_dentry)
 270 {
 271         struct hfsplus_sb_info *sbi = HFSPLUS_SB(dst_dir->i_sb);
 272         struct inode *inode = src_dentry->d_inode;
 273         struct inode *src_dir = src_dentry->d_parent->d_inode;
 274         struct qstr str;
 275         char name[32];
 276         u32 cnid, id;
 277         int res;
 278
 279         if (HFSPLUS_IS_RSRC(inode))
 280                 return -EPERM;
 281         if (!S_ISREG(inode->i_mode))
 282                 return -EPERM;
 283
 284         mutex_lock(&sbi->vh_mutex);
 285         if (inode->i_ino == (u32)(unsigned long)src_dentry->d_fsdata) {
 286                 for (;;) {
 287                         get_random_bytes(&id, sizeof(cnid));
 288                         id &= 0x3fffffff;
 289                         str.name = name;
 290                         str.len = sprintf(name, "iNode%d", id);
 291                         res = hfsplus_rename_cat(inode->i_ino,
 292                                                  src_dir, &src_dentry->d_name,
 293                                                  sbi->hidden_dir, &str);
 294                         if (!res)
 295                                 break;
 296                         if (res != -EEXIST)
 297                                 goto out;
 298                 }
 299                 HFSPLUS_I(inode)->linkid = id;
 300                 cnid = sbi->next_cnid++;
 301                 src_dentry->d_fsdata = (void *)(unsigned long)cnid;
 302                 res = hfsplus_create_cat(cnid, src_dir,
 303                         &src_dentry->d_name, inode);
 304                 if (res)
 305                         /* panic? */
 306                         goto out;
 307                 sbi->file_count++;
 308         }
 309         cnid = sbi->next_cnid++;
 310         res = hfsplus_create_cat(cnid, dst_dir, &dst_dentry->d_name, inode);
 311         if (res)
 312                 goto out;
 313
 314         inc_nlink(inode);
 315         hfsplus_instantiate(dst_dentry, inode, cnid);
 316         ihold(inode);
 317         inode->i_ctime = CURRENT_TIME_SEC;
 318         mark_inode_dirty(inode);
 319         sbi->file_count++;
 320         hfsplus_mark_mdb_dirty(dst_dir->i_sb);
 321 out:
 322         mutex_unlock(&sbi->vh_mutex);
 323         return res;
 324 }
 325
 326 static int hfsplus_unlink(struct inode *dir, struct dentry *dentry)
 327 {
 328         struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb);
 329         struct inode *inode = dentry->d_inode;
 330         struct qstr str;
 331         char name[32];
 332         u32 cnid;
 333         int res;
 334
 335         if (HFSPLUS_IS_RSRC(inode))
 336                 return -EPERM;
 337
 338         mutex_lock(&sbi->vh_mutex);
 339         cnid = (u32)(unsigned long)dentry->d_fsdata;
 340         if (inode->i_ino == cnid &&
 341             atomic_read(&HFSPLUS_I(inode)->opencnt)) {
 342                 str.name = name;
 343                 str.len = sprintf(name, "temp%lu", inode->i_ino);
 344                 res = hfsplus_rename_cat(inode->i_ino,
 345                                          dir, &dentry->d_name,
 346                                          sbi->hidden_dir, &str);
 347                 if (!res) {
 348                         inode->i_flags |= S_DEAD;
 349                         drop_nlink(inode);
 350                 }
 351                 goto out;
 352         }
 353         res = hfsplus_delete_cat(cnid, dir, &dentry->d_name);
 354         if (res)
 355                 goto out;
 356
 357         if (inode->i_nlink > 0)
 358                 drop_nlink(inode);
 359         if (inode->i_ino == cnid)
 360                 clear_nlink(inode);
 361         if (!inode->i_nlink) {
 362                 if (inode->i_ino != cnid) {
 363                         sbi->file_count--;
 364                         if (!atomic_read(&HFSPLUS_I(inode)->opencnt)) {
 365                                 res = hfsplus_delete_cat(inode->i_ino,
 366                                                          sbi->hidden_dir,
 367                                                          NULL);
 368                                 if (!res)
 369                                         hfsplus_delete_inode(inode);
 370                         } else
 371                                 inode->i_flags |= S_DEAD;
 372                 } else
 373                         hfsplus_delete_inode(inode);
 374         } else
 375                 sbi->file_count--;
 376         inode->i_ctime = CURRENT_TIME_SEC;
 377         mark_inode_dirty(inode);
 378 out:
 379         mutex_unlock(&sbi->vh_mutex);
 380         return res;
 381 }
 382
 383 static int hfsplus_rmdir(struct inode *dir, struct dentry *dentry)
 384 {
 385         struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb);
 386         struct inode *inode = dentry->d_inode;
 387         int res;
 388
 389         if (inode->i_size != 2)
 390                 return -ENOTEMPTY;
 391
 392         mutex_lock(&sbi->vh_mutex);
 393         res = hfsplus_delete_cat(inode->i_ino, dir, &dentry->d_name);
 394         if (res)
 395                 goto out;
 396         clear_nlink(inode);
 397         inode->i_ctime = CURRENT_TIME_SEC;
 398         hfsplus_delete_inode(inode);
 399         mark_inode_dirty(inode);
 400 out:
 401         mutex_unlock(&sbi->vh_mutex);
 402         return res;
 403 }
 404
 405 static int hfsplus_symlink(struct inode *dir, struct dentry *dentry,
 406                            const char *symname)
 407 {
 408         struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb);
 409         struct inode *inode;
 410         int res = -ENOSPC;
 411
 412         mutex_lock(&sbi->vh_mutex);
 413         inode = hfsplus_new_inode(dir->i_sb, S_IFLNK | S_IRWXUGO);
 414         if (!inode)
 415                 goto out;
 416
 417         res = page_symlink(inode, symname, strlen(symname) + 1);
 418         if (res)
 419                 goto out_err;
 420
 421         res = hfsplus_create_cat(inode->i_ino, dir, &dentry->d_name, inode);
 422         if (res)
 423                 goto out_err;
 424
 425         res = hfsplus_init_inode_security(inode, dir, &dentry->d_name);
 426         if (res == -EOPNOTSUPP)
 427                 res = 0; /* Operation is not supported. */
 428         else if (res) {
 429                 /* Try to delete anyway without error analysis. */
 430                 hfsplus_delete_cat(inode->i_ino, dir, &dentry->d_name);
 431                 goto out_err;
 432         }
 433
 434         hfsplus_instantiate(dentry, inode, inode->i_ino);
 435         mark_inode_dirty(inode);
 436         goto out;
 437
 438 out_err:
 439         clear_nlink(inode);
 440         hfsplus_delete_inode(inode);
 441         iput(inode);
 442 out:
 443         mutex_unlock(&sbi->vh_mutex);
 444         return res;
 445 }
 446
 447 static int hfsplus_mknod(struct inode *dir, struct dentry *dentry,
 448                          umode_t mode, dev_t rdev)
 449 {
 450         struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb);
 451         struct inode *inode;
 452         int res = -ENOSPC;
 453
 454         mutex_lock(&sbi->vh_mutex);
 455         inode = hfsplus_new_inode(dir->i_sb, mode);
 456         if (!inode)
 457                 goto out;
 458
 459         if (S_ISBLK(mode) || S_ISCHR(mode) || S_ISFIFO(mode) || S_ISSOCK(mode))
 460                 init_special_inode(inode, mode, rdev);
 461
 462         res = hfsplus_create_cat(inode->i_ino, dir, &dentry->d_name, inode);
 463         if (res)
 464                 goto failed_mknod;
 465
 466         res = hfsplus_init_inode_security(inode, dir, &dentry->d_name);
 467         if (res == -EOPNOTSUPP)
 468                 res = 0; /* Operation is not supported. */
 469         else if (res) {
 470                 /* Try to delete anyway without error analysis. */
 471                 hfsplus_delete_cat(inode->i_ino, dir, &dentry->d_name);
 472                 goto failed_mknod;
 473         }
 474
 475         hfsplus_instantiate(dentry, inode, inode->i_ino);
 476         mark_inode_dirty(inode);
 477         goto out;
 478
 479 failed_mknod:
 480         clear_nlink(inode);
 481         hfsplus_delete_inode(inode);
 482         iput(inode);
 483 out:
 484         mutex_unlock(&sbi->vh_mutex);
 485         return res;
 486 }
 487
 488 static int hfsplus_create(struct inode *dir, struct dentry *dentry, umode_t mode,
 489                           bool excl)
 490 {
 491         return hfsplus_mknod(dir, dentry, mode, 0);
 492 }
 493
 494 static int hfsplus_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 495 {
 496         return hfsplus_mknod(dir, dentry, mode | S_IFDIR, 0);
 497 }
 498
 499 static int hfsplus_rename(struct inode *old_dir, struct dentry *old_dentry,
 500                           struct inode *new_dir, struct dentry *new_dentry)
 501 {
 502         int res;
 503
 504         /* Unlink destination if it already exists */
 505         if (new_dentry->d_inode) {
 506                 if (S_ISDIR(new_dentry->d_inode->i_mode))
 507                         res = hfsplus_rmdir(new_dir, new_dentry);
 508                 else
 509                         res = hfsplus_unlink(new_dir, new_dentry);
 510                 if (res)
 511                         return res;
 512         }
 513
 514         res = hfsplus_rename_cat((u32)(unsigned long)old_dentry->d_fsdata,
 515                                  old_dir, &old_dentry->d_name,
 516                                  new_dir, &new_dentry->d_name);
 517         if (!res)
 518                 new_dentry->d_fsdata = old_dentry->d_fsdata;
 519         return res;
 520 }
 521
 522 const struct inode_operations hfsplus_dir_inode_operations = {
 523         .lookup                 = hfsplus_lookup,
 524         .create                 = hfsplus_create,
 525         .link                   = hfsplus_link,
 526         .unlink                 = hfsplus_unlink,
 527         .mkdir                  = hfsplus_mkdir,
 528         .rmdir                  = hfsplus_rmdir,
 529         .symlink                = hfsplus_symlink,
 530         .mknod                  = hfsplus_mknod,
 531         .rename                 = hfsplus_rename,
 532         .setxattr               = generic_setxattr,
 533         .getxattr               = generic_getxattr,
 534         .listxattr              = hfsplus_listxattr,
 535         .removexattr            = hfsplus_removexattr,
 536 };
 537
 538 const struct file_operations hfsplus_dir_operations = {
 539         .fsync          = hfsplus_file_fsync,
 540         .read           = generic_read_dir,
 541         .readdir        = hfsplus_readdir,
 542         .unlocked_ioctl = hfsplus_ioctl,
 543         .llseek         = generic_file_llseek,
 544         .release        = hfsplus_dir_release,
 545 };