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