FreeBSD/Linux Kernel Cross Reference
sys/fs/hfs/dir_dbl.c

     /*
      * linux/fs/hfs/dir_dbl.c
      *
      * Copyright (C) 1995-1997  Paul H. Hargrove
      * This file may be distributed under the terms of the GNU General Public License.
      *
      * This file contains the inode_operations and file_operations
      * structures for HFS directories.
      *
     * Based on the minix file system code, (C) 1991, 1992 by Linus Torvalds
     *
     * "XXX" in a comment is a note to myself to consider changing something.
     *
     * In function preconditions the term "valid" applied to a pointer to
     * a structure means that the pointer is non-NULL and the structure it
     * points to has all fields initialized to consistent values.
     */
    
    #include "hfs.h"
    #include <linux/hfs_fs_sb.h>
    #include <linux/hfs_fs_i.h>
    #include <linux/hfs_fs.h>
    
    /*================ Forward declarations ================*/
    
    static struct dentry *dbl_lookup(struct inode *, struct dentry *);
    static int dbl_readdir(struct file *, void *, filldir_t);
    static int dbl_create(struct inode *, struct dentry *, int);
    static int dbl_mkdir(struct inode *, struct dentry *, int);
    static int dbl_unlink(struct inode *, struct dentry *);
    static int dbl_rmdir(struct inode *, struct dentry *);
    static int dbl_rename(struct inode *, struct dentry *,
                          struct inode *, struct dentry *);
    
    /*================ Global variables ================*/
    
    #define DOT_LEN                 1
    #define DOT_DOT_LEN             2
    #define ROOTINFO_LEN            8
    #define PCNT_ROOTINFO_LEN       9
    
    const struct hfs_name hfs_dbl_reserved1[] = {
            {DOT_LEN,               "."},
            {DOT_DOT_LEN,           ".."},
            {0,                     ""},
    };
    
    const struct hfs_name hfs_dbl_reserved2[] = {
            {ROOTINFO_LEN,          "RootInfo"},
            {PCNT_ROOTINFO_LEN,     "%RootInfo"},
            {0,                     ""},
    };
    
    #define DOT             (&hfs_dbl_reserved1[0])
    #define DOT_DOT         (&hfs_dbl_reserved1[1])
    #define ROOTINFO        (&hfs_dbl_reserved2[0])
    #define PCNT_ROOTINFO   (&hfs_dbl_reserved2[1])
    
    struct file_operations hfs_dbl_dir_operations = {
            read:           generic_read_dir,
            readdir:        dbl_readdir,
            fsync:          file_fsync,
    };
    
    struct inode_operations hfs_dbl_dir_inode_operations = {
            create:         dbl_create,
            lookup:         dbl_lookup,
            unlink:         dbl_unlink,
            mkdir:          dbl_mkdir,
            rmdir:          dbl_rmdir,
            rename:         dbl_rename,
            setattr:        hfs_notify_change,
    };
    
    
    /*================ File-local functions ================*/
    
    /*
     * is_hdr()
     */
    static int is_hdr(struct inode *dir, const char *name, int len)
    {
            int retval = 0;
    
            if (name[0] == '%') {
                    struct hfs_cat_entry *entry = HFS_I(dir)->entry;
                    struct hfs_cat_entry *victim;
                    struct hfs_name cname;
                    struct hfs_cat_key key;
    
                    hfs_nameout(dir, &cname, name+1, len-1);
                    hfs_cat_build_key(entry->cnid, &cname, &key);
                    if ((victim = hfs_cat_get(entry->mdb, &key))) {
                            hfs_cat_put(victim);
                            retval = 1;
                    }
            }
            return retval;
    }
   
   /*
    * dbl_lookup()
    *
    * This is the lookup() entry in the inode_operations structure for
    * HFS directories in the AppleDouble scheme.  The purpose is to
    * generate the inode corresponding to an entry in a directory, given
    * the inode for the directory and the name (and its length) of the
    * entry.
    */
   static struct dentry *dbl_lookup(struct inode * dir, struct dentry *dentry)
   {
           struct hfs_name cname;
           struct hfs_cat_entry *entry;
           struct hfs_cat_key key;
           struct inode *inode = NULL;
   
           dentry->d_op = &hfs_dentry_operations;
           entry = HFS_I(dir)->entry;
           
           /* Perform name-mangling */
           hfs_nameout(dir, &cname, dentry->d_name.name, dentry->d_name.len);
    
           /* no need to check for "."  or ".." */
   
           /* Check for "%RootInfo" if in the root directory. */
           if ((entry->cnid == htonl(HFS_ROOT_CNID)) &&
               hfs_streq(cname.Name, cname.Len, 
                         PCNT_ROOTINFO->Name, PCNT_ROOTINFO_LEN)) {
                   ++entry->count; /* __hfs_iget() eats one */
                   inode = hfs_iget(entry, HFS_DBL_HDR, dentry);
                   goto done;
           }
   
           /* Do an hfs_iget() on the mangled name. */
           hfs_cat_build_key(entry->cnid, &cname, &key);
           inode = hfs_iget(hfs_cat_get(entry->mdb, &key), HFS_DBL_NORM, dentry);
   
           /* Try as a header if not found and first character is '%' */
           if (!inode && (dentry->d_name.name[0] == '%')) {
                   hfs_nameout(dir, &cname, dentry->d_name.name+1,
                               dentry->d_name.len-1);
                   hfs_cat_build_key(entry->cnid, &cname, &key);
                   inode = hfs_iget(hfs_cat_get(entry->mdb, &key),
                                    HFS_DBL_HDR, dentry);
           }
           
   done:
           d_add(dentry, inode);
           return NULL;
   }
   
   /*
    * dbl_readdir()
    *
    * This is the readdir() entry in the file_operations structure for
    * HFS directories in the AppleDouble scheme.  The purpose is to
    * enumerate the entries in a directory, given the inode of the
    * directory and a (struct file *), the 'f_pos' field of which
    * indicates the location in the directory.  The (struct file *) is
    * updated so that the next call with the same 'dir' and 'filp'
    * arguments will produce the next directory entry.  The entries are
    * returned in 'dirent', which is "filled-in" by calling filldir().
    * This allows the same readdir() function be used for different
    * formats.  We try to read in as many entries as we can before
    * filldir() refuses to take any more.
    *
    * XXX: In the future it may be a good idea to consider not generating
    * metadata files for covered directories since the data doesn't
    * correspond to the mounted directory.  However this requires an
    * iget() for every directory which could be considered an excessive
    * amount of overhead.  Since the inode for a mount point is always
    * in-core this is another argument for a call to get an inode if it
    * is in-core or NULL if it is not.
    */
   static int dbl_readdir(struct file * filp,
                          void * dirent, filldir_t filldir)
   {
           struct hfs_brec brec;
           struct hfs_cat_entry *entry;
           struct inode *dir = filp->f_dentry->d_inode;
   
           entry = HFS_I(dir)->entry;
   
           if (filp->f_pos == 0) {
                   /* Entry 0 is for "." */
                   if (filldir(dirent, DOT->Name, DOT_LEN, 0, dir->i_ino,
                               DT_DIR)) {
                           return 0;
                   }
                   filp->f_pos = 1;
           }
   
           if (filp->f_pos == 1) {
                   /* Entry 1 is for ".." */
                   if (filldir(dirent, DOT_DOT->Name, DOT_DOT_LEN, 1,
                               hfs_get_hl(entry->key.ParID), DT_DIR)) {
                           return 0;
                   }
                   filp->f_pos = 2;
           }
   
           if (filp->f_pos < (dir->i_size - 1)) {
                   hfs_u32 cnid;
                   hfs_u8 type;
   
                   if (hfs_cat_open(entry, &brec) ||
                       hfs_cat_next(entry, &brec, (filp->f_pos - 1) >> 1,
                                    &cnid, &type)) {
                           return 0;
                   }
   
                   while (filp->f_pos < (dir->i_size - 1)) {
                           unsigned char tmp_name[HFS_NAMEMAX + 1];
                           ino_t ino;
                           int is_hdr = (filp->f_pos & 1);
                           unsigned int len;
   
                           if (is_hdr) {
                                   ino = ntohl(cnid) | HFS_DBL_HDR;
                                   tmp_name[0] = '%';
                                   len = 1 + hfs_namein(dir, tmp_name + 1,
                                       &((struct hfs_cat_key *)brec.key)->CName);
                           } else {
                                   if (hfs_cat_next(entry, &brec, 1,
                                                           &cnid, &type)) {
                                           return 0;
                                   }
                                   ino = ntohl(cnid);
                                   len = hfs_namein(dir, tmp_name,
                                       &((struct hfs_cat_key *)brec.key)->CName);
                           }
   
                           if (filldir(dirent, tmp_name, len, filp->f_pos, ino,
                                       DT_UNKNOWN)) {
                                   hfs_cat_close(entry, &brec);
                                   return 0;
                           }
                           ++filp->f_pos;
                   }
                   hfs_cat_close(entry, &brec);
           }
   
           if (filp->f_pos == (dir->i_size - 1)) {
                   if (entry->cnid == htonl(HFS_ROOT_CNID)) {
                           /* In root dir last entry is for "%RootInfo" */
                           if (filldir(dirent, PCNT_ROOTINFO->Name,
                                       PCNT_ROOTINFO_LEN, filp->f_pos,
                                       ntohl(entry->cnid) | HFS_DBL_HDR,
                                       DT_UNKNOWN)) {
                                   return 0;
                           }
                   }
                   ++filp->f_pos;
           }
   
           return 0;
   }
   
   /*
    * dbl_create()
    *
    * This is the create() entry in the inode_operations structure for
    * AppleDouble directories.  The purpose is to create a new file in
    * a directory and return a corresponding inode, given the inode for
    * the directory and the name (and its length) of the new file.
    */
   static int dbl_create(struct inode * dir, struct dentry *dentry,
                         int mode)
   {
           int error;
   
           if (is_hdr(dir, dentry->d_name.name, dentry->d_name.len)) {
                   error = -EEXIST;
           } else {
                   error = hfs_create(dir, dentry, mode);
           }
           return error;
   }
   
   /*
    * dbl_mkdir()
    *
    * This is the mkdir() entry in the inode_operations structure for
    * AppleDouble directories.  The purpose is to create a new directory
    * in a directory, given the inode for the parent directory and the
    * name (and its length) of the new directory.
    */
   static int dbl_mkdir(struct inode * parent, struct dentry *dentry,
                        int mode)
   {
           int error;
   
           if (is_hdr(parent, dentry->d_name.name, dentry->d_name.len)) {
                   error = -EEXIST;
           } else {
                   error = hfs_mkdir(parent, dentry, mode);
           }
           return error;
   }
   
   /*
    * dbl_unlink()
    *
    * This is the unlink() entry in the inode_operations structure for
    * AppleDouble directories.  The purpose is to delete an existing
    * file, given the inode for the parent directory and the name
    * (and its length) of the existing file.
    */
   static int dbl_unlink(struct inode * dir, struct dentry *dentry)
   {
           int error;
   
           error = hfs_unlink(dir, dentry);
           if ((error == -ENOENT) && is_hdr(dir, dentry->d_name.name,
                                            dentry->d_name.len)) {
                   error = -EPERM;
           }
           return error;
   }
   
   /*
    * dbl_rmdir()
    *
    * This is the rmdir() entry in the inode_operations structure for
    * AppleDouble directories.  The purpose is to delete an existing
    * directory, given the inode for the parent directory and the name
    * (and its length) of the existing directory.
    */
   static int dbl_rmdir(struct inode * parent, struct dentry *dentry)
   {
           int error;
   
           error = hfs_rmdir(parent, dentry);
           if ((error == -ENOENT) && is_hdr(parent, dentry->d_name.name,
                                            dentry->d_name.len)) {
                   error = -ENOTDIR;
           }
           return error;
   }
   
   /*
    * dbl_rename()
    *
    * This is the rename() entry in the inode_operations structure for
    * AppleDouble directories.  The purpose is to rename an existing
    * file or directory, given the inode for the current directory and
    * the name (and its length) of the existing file/directory and the
    * inode for the new directory and the name (and its length) of the
    * new file/directory.
    * 
    * XXX: how do we handle must_be_dir?
    */
   static int dbl_rename(struct inode *old_dir, struct dentry *old_dentry,
                         struct inode *new_dir, struct dentry *new_dentry)
   {
           int error;
   
           if (is_hdr(new_dir, new_dentry->d_name.name,
                      new_dentry->d_name.len)) {
                   error = -EPERM;
           } else {
                   error = hfs_rename(old_dir, old_dentry,
                                      new_dir, new_dentry);
                   if ((error == -ENOENT) /*&& !must_be_dir*/ &&
                       is_hdr(old_dir, old_dentry->d_name.name,
                              old_dentry->d_name.len)) {
                           error = -EPERM;
                   }
           }
           return error;
   }
   
   
   /* due to the dcache caching negative dentries for non-existent files,
    * we need to drop those entries when a file silently gets created.
    * as far as i can tell, the calls that need to do this are the file
    * related calls (create, rename, and mknod). the directory calls
    * should be immune. the relevant calls in dir.c call drop_dentry 
    * upon successful completion. */
   void hfs_dbl_drop_dentry(struct dentry *dentry, const ino_t type)
   {
     unsigned char tmp_name[HFS_NAMEMAX + 1];
     struct dentry *de = NULL;
   
     switch (type) {
     case HFS_DBL_HDR:
      /* given %name, look for name. i don't think this happens. */
      de = hfs_lookup_dentry(dentry->d_parent,
                             dentry->d_name.name + 1, dentry->d_name.len - 1);
       break;
     case HFS_DBL_DATA:
       /* given name, look for %name */
       tmp_name[0] = '%';
       strncpy(tmp_name + 1, dentry->d_name.name, HFS_NAMELEN - 1);
       de = hfs_lookup_dentry(dentry->d_parent, 
                              tmp_name, dentry->d_name.len + 1);
     }
   
     if (de) {
       if (!de->d_inode)
         d_drop(de);
       dput(de);
     }
   }

Cache object: 3376b5e76c279b379079311def9ddb4e