fs/hfs/dir_cap.c

   1 /*
   2  * Copyright (C) 1995-1997  Paul H. Hargrove
   3  * This file may be distributed under the terms of the GNU General Public License.
   4  *
   5  * This file contains the inode_operations and file_operations
   6  * structures for HFS directories under the CAP scheme.
   7  *
   8  * Based on the minix file system code, (C) 1991, 1992 by Linus Torvalds
   9  *
  10  * The source code distribution of the Columbia AppleTalk Package for
  11  * UNIX, version 6.0, (CAP) was used as a specification of the
  12  * location and format of files used by CAP's Aufs.  No code from CAP
  13  * appears in hfs_fs.  hfs_fs is not a work ``derived'' from CAP in
  14  * the sense of intellectual property law.
  15  *
  16  * "XXX" in a comment is a note to myself to consider changing something.
  17  *
  18  * In function preconditions the term "valid" applied to a pointer to
  19  * a structure means that the pointer is non-NULL and the structure it
  20  * points to has all fields initialized to consistent values.
  21  */
  22
  23 #include "hfs.h"
  24 #include <linux/hfs_fs_sb.h>
  25 #include <linux/hfs_fs_i.h>
  26 #include <linux/hfs_fs.h>
  27
  28 /*================ Forward declarations ================*/
  29
  30 static struct dentry *cap_lookup(struct inode *, struct dentry *);
  31 static int cap_readdir(struct file *, void *, filldir_t);
  32
  33 /*================ Global variables ================*/
  34
  35 #define DOT_LEN                 1
  36 #define DOT_DOT_LEN             2
  37 #define DOT_RESOURCE_LEN        9
  38 #define DOT_FINDERINFO_LEN      11
  39 #define DOT_ROOTINFO_LEN        9
  40
  41 const struct hfs_name hfs_cap_reserved1[] = {
  42         {DOT_LEN,               "."},
  43         {DOT_DOT_LEN,           ".."},
  44         {DOT_RESOURCE_LEN,      ".resource"},
  45         {DOT_FINDERINFO_LEN,    ".finderinfo"},
  46         {0,                     ""},
  47 };
  48
  49 const struct hfs_name hfs_cap_reserved2[] = {
  50         {DOT_ROOTINFO_LEN,      ".rootinfo"},
  51         {0,                     ""},
  52 };
  53
  54 #define DOT             (&hfs_cap_reserved1[0])
  55 #define DOT_DOT         (&hfs_cap_reserved1[1])
  56 #define DOT_RESOURCE    (&hfs_cap_reserved1[2])
  57 #define DOT_FINDERINFO  (&hfs_cap_reserved1[3])
  58 #define DOT_ROOTINFO    (&hfs_cap_reserved2[0])
  59
  60 struct file_operations hfs_cap_dir_operations = {
  61         read:           generic_read_dir,
  62         readdir:        cap_readdir,
  63         fsync:          file_fsync,
  64 };
  65
  66 struct inode_operations hfs_cap_ndir_inode_operations = {
  67         create:         hfs_create,
  68         lookup:         cap_lookup,
  69         unlink:         hfs_unlink,
  70         mkdir:          hfs_mkdir,
  71         rmdir:          hfs_rmdir,
  72         rename:         hfs_rename,
  73         setattr:        hfs_notify_change,
  74 };
  75
  76 struct inode_operations hfs_cap_fdir_inode_operations = {
  77         lookup:         cap_lookup,
  78         setattr:        hfs_notify_change,
  79 };
  80
  81 struct inode_operations hfs_cap_rdir_inode_operations = {
  82         create:         hfs_create,
  83         lookup:         cap_lookup,
  84         setattr:        hfs_notify_change,
  85 };
  86
  87 /*================ File-local functions ================*/
  88
  89 /*
  90  * cap_lookup()
  91  *
  92  * This is the lookup() entry in the inode_operations structure for
  93  * HFS directories in the CAP scheme.  The purpose is to generate the
  94  * inode corresponding to an entry in a directory, given the inode for
  95  * the directory and the name (and its length) of the entry.
  96  */
  97 static struct dentry *cap_lookup(struct inode * dir, struct dentry *dentry)
  98 {
  99         ino_t dtype;
 100         struct hfs_name cname;
 101         struct hfs_cat_entry *entry;
 102         struct hfs_cat_key key;
 103         struct inode *inode = NULL;
 104
 105         dentry->d_op = &hfs_dentry_operations;
 106         entry = HFS_I(dir)->entry;
 107         dtype = HFS_ITYPE(dir->i_ino);
 108
 109         /* Perform name-mangling */
 110         hfs_nameout(dir, &cname, dentry->d_name.name,
 111                     dentry->d_name.len);
 112
 113         /* no need to check for "."  or ".." */
 114
 115         /* Check for special directories if in a normal directory.
 116            Note that cap_dupdir() does an iput(dir). */
 117         if (dtype==HFS_CAP_NDIR) {
 118                 /* Check for ".resource", ".finderinfo" and ".rootinfo" */
 119                 if (hfs_streq(cname.Name, cname.Len,
 120                               DOT_RESOURCE->Name, DOT_RESOURCE_LEN)) {
 121                         ++entry->count; /* __hfs_iget() eats one */
 122                         inode = hfs_iget(entry, HFS_CAP_RDIR, dentry);
 123                         goto done;
 124                 } else if (hfs_streq(cname.Name, cname.Len,
 125                                      DOT_FINDERINFO->Name,
 126                                      DOT_FINDERINFO_LEN)) {
 127                         ++entry->count; /* __hfs_iget() eats one */
 128                         inode = hfs_iget(entry, HFS_CAP_FDIR, dentry);
 129                         goto done;
 130                 } else if ((entry->cnid == htonl(HFS_ROOT_CNID)) &&
 131                            hfs_streq(cname.Name, cname.Len,
 132                                      DOT_ROOTINFO->Name, DOT_ROOTINFO_LEN)) {
 133                         ++entry->count; /* __hfs_iget() eats one */
 134                         inode = hfs_iget(entry, HFS_CAP_FNDR, dentry);
 135                         goto done;
 136                 }
 137         }
 138
 139         /* Do an hfs_iget() on the mangled name. */
 140         hfs_cat_build_key(entry->cnid, &cname, &key);
 141         inode = hfs_iget(hfs_cat_get(entry->mdb, &key),
 142                          HFS_I(dir)->file_type, dentry);
 143
 144         /* Don't return a resource fork for a directory */
 145         if (inode && (dtype == HFS_CAP_RDIR) &&
 146             (HFS_I(inode)->entry->type == HFS_CDR_DIR)) {
 147                 iput(inode); /* this does an hfs_cat_put */
 148                 inode = NULL;
 149         }
 150
 151 done:
 152         d_add(dentry, inode);
 153         return NULL;
 154 }
 155
 156 /*
 157  * cap_readdir()
 158  *
 159  * This is the readdir() entry in the file_operations structure for
 160  * HFS directories in the CAP scheme.  The purpose is to enumerate the
 161  * entries in a directory, given the inode of the directory and a
 162  * (struct file *), the 'f_pos' field of which indicates the location
 163  * in the directory.  The (struct file *) is updated so that the next
 164  * call with the same 'dir' and 'filp' arguments will produce the next
 165  * directory entry.  The entries are returned in 'dirent', which is
 166  * "filled-in" by calling filldir().  This allows the same readdir()
 167  * function be used for different dirent formats.  We try to read in
 168  * as many entries as we can before filldir() refuses to take any more.
 169  *
 170  * XXX: In the future it may be a good idea to consider not generating
 171  * metadata files for covered directories since the data doesn't
 172  * correspond to the mounted directory.  However this requires an
 173  * iget() for every directory which could be considered an excessive
 174  * amount of overhead.  Since the inode for a mount point is always
 175  * in-core this is another argument for a call to get an inode if it
 176  * is in-core or NULL if it is not.
 177  */
 178 static int cap_readdir(struct file * filp,
 179                        void * dirent, filldir_t filldir)
 180 {
 181         ino_t type;
 182         int skip_dirs;
 183         struct hfs_brec brec;
 184         struct hfs_cat_entry *entry;
 185         struct inode *dir = filp->f_dentry->d_inode;
 186
 187         entry = HFS_I(dir)->entry;
 188         type = HFS_ITYPE(dir->i_ino);
 189         skip_dirs = (type == HFS_CAP_RDIR);
 190
 191         if (filp->f_pos == 0) {
 192                 /* Entry 0 is for "." */
 193                 if (filldir(dirent, DOT->Name, DOT_LEN, 0, dir->i_ino, DT_DIR)) {
 194                         return 0;
 195                 }
 196                 filp->f_pos = 1;
 197         }
 198
 199         if (filp->f_pos == 1) {
 200                 /* Entry 1 is for ".." */
 201                 hfs_u32 cnid;
 202
 203                 if (type == HFS_CAP_NDIR) {
 204                         cnid = hfs_get_nl(entry->key.ParID);
 205                 } else {
 206                         cnid = entry->cnid;
 207                 }
 208
 209                 if (filldir(dirent, DOT_DOT->Name,
 210                             DOT_DOT_LEN, 1, ntohl(cnid), DT_DIR)) {
 211                         return 0;
 212                 }
 213                 filp->f_pos = 2;
 214         }
 215
 216         if (filp->f_pos < (dir->i_size - 3)) {
 217                 hfs_u32 cnid;
 218                 hfs_u8 type;
 219
 220                 if (hfs_cat_open(entry, &brec) ||
 221                     hfs_cat_next(entry, &brec, filp->f_pos - 2, &cnid, &type)) {
 222                         return 0;
 223                 }
 224                 while (filp->f_pos < (dir->i_size - 3)) {
 225                         if (hfs_cat_next(entry, &brec, 1, &cnid, &type)) {
 226                                 return 0;
 227                         }
 228                         if (!skip_dirs || (type != HFS_CDR_DIR)) {
 229                                 ino_t ino;
 230                                 unsigned int len;
 231                                 unsigned char tmp_name[HFS_NAMEMAX];
 232
 233                                 ino = ntohl(cnid) | HFS_I(dir)->file_type;
 234                                 len = hfs_namein(dir, tmp_name,
 235                                     &((struct hfs_cat_key *)brec.key)->CName);
 236                                 if (filldir(dirent, tmp_name, len,
 237                                             filp->f_pos, ino, DT_UNKNOWN)) {
 238                                         hfs_cat_close(entry, &brec);
 239                                         return 0;
 240                                 }
 241                         }
 242                         ++filp->f_pos;
 243                 }
 244                 hfs_cat_close(entry, &brec);
 245         }
 246
 247         if (filp->f_pos == (dir->i_size - 3)) {
 248                 if ((entry->cnid == htonl(HFS_ROOT_CNID)) &&
 249                     (type == HFS_CAP_NDIR)) {
 250                         /* In root dir last-2 entry is for ".rootinfo" */
 251                         if (filldir(dirent, DOT_ROOTINFO->Name,
 252                                     DOT_ROOTINFO_LEN, filp->f_pos,
 253                                     ntohl(entry->cnid) | HFS_CAP_FNDR,
 254                                     DT_UNKNOWN)) {
 255                                 return 0;
 256                         }
 257                 }
 258                 ++filp->f_pos;
 259         }
 260
 261         if (filp->f_pos == (dir->i_size - 2)) {
 262                 if (type == HFS_CAP_NDIR) {
 263                         /* In normal dirs last-1 entry is for ".finderinfo" */
 264                         if (filldir(dirent, DOT_FINDERINFO->Name,
 265                                     DOT_FINDERINFO_LEN, filp->f_pos,
 266                                     ntohl(entry->cnid) | HFS_CAP_FDIR,
 267                                     DT_UNKNOWN)) {
 268                                 return 0;
 269                         }
 270                 }
 271                 ++filp->f_pos;
 272         }
 273
 274         if (filp->f_pos == (dir->i_size - 1)) {
 275                 if (type == HFS_CAP_NDIR) {
 276                         /* In normal dirs last entry is for ".resource" */
 277                         if (filldir(dirent, DOT_RESOURCE->Name,
 278                                     DOT_RESOURCE_LEN, filp->f_pos,
 279                                     ntohl(entry->cnid) | HFS_CAP_RDIR,
 280                                     DT_UNKNOWN)) {
 281                                 return 0;
 282                         }
 283                 }
 284                 ++filp->f_pos;
 285         }
 286
 287         return 0;
 288 }
 289
 290
 291 /* due to the dcache caching negative dentries for non-existent files,
 292  * we need to drop those entries when a file silently gets created.
 293  * as far as i can tell, the calls that need to do this are the file
 294  * related calls (create, rename, and mknod). the directory calls
 295  * should be immune. the relevant calls in dir.c call drop_dentry
 296  * upon successful completion. */
 297 void hfs_cap_drop_dentry(struct dentry *dentry, const ino_t type)
 298 {
 299   if (type == HFS_CAP_DATA) { /* given name */
 300     hfs_drop_special(dentry->d_parent, DOT_FINDERINFO, dentry);
 301     hfs_drop_special(dentry->d_parent, DOT_RESOURCE, dentry);
 302   } else {
 303     struct dentry *de;
 304
 305     /* given {.resource,.finderinfo}/name, look for name */
 306     if ((de = hfs_lookup_dentry(dentry->d_parent->d_parent,
 307                                 dentry->d_name.name, dentry->d_name.len))) {
 308       if (!de->d_inode)
 309         d_drop(de);
 310       dput(de);
 311     }
 312
 313     switch (type) {
 314     case HFS_CAP_RSRC: /* given .resource/name */
 315        /* look for .finderinfo/name */
 316       hfs_drop_special(dentry->d_parent->d_parent, DOT_FINDERINFO,
 317                        dentry);
 318       break;
 319     case HFS_CAP_FNDR: /* given .finderinfo/name. i don't this
 320                         * happens. */
 321       /* look for .resource/name */
 322       hfs_drop_special(dentry->d_parent->d_parent, DOT_RESOURCE,
 323                        dentry);
 324       break;
 325     }
 326   }
 327 }