LXR linux/fs/isofs/export.c

   1/*
   2 * fs/isofs/export.c
   3 *
   4 *  (C) 2004  Paul Serice - The new inode scheme requires switching
   5 *                          from iget() to iget5_locked() which means
   6 *                          the NFS export operations have to be hand
   7 *                          coded because the default routines rely on
   8 *                          iget().
   9 *
  10 * The following files are helpful:
  11 *
  12 *     Documentation/filesystems/Exporting
  13 *     fs/exportfs/expfs.c.
  14 */
  15
  16#include "isofs.h"
  17
  18static struct dentry *
  19isofs_export_iget(struct super_block *sb,
  20                  unsigned long block,
  21                  unsigned long offset,
  22                  __u32 generation)
  23{
  24        struct inode *inode;
  25        struct dentry *result;
  26        if (block == 0)
  27                return ERR_PTR(-ESTALE);
  28        inode = isofs_iget(sb, block, offset);
  29        if (inode == NULL)
  30                return ERR_PTR(-ENOMEM);
  31        if (is_bad_inode(inode)
  32            || (generation && inode->i_generation != generation))
  33        {
  34                iput(inode);
  35                return ERR_PTR(-ESTALE);
  36        }
  37        result = d_alloc_anon(inode);
  38        if (!result) {
  39                iput(inode);
  40                return ERR_PTR(-ENOMEM);
  41        }
  42        return result;
  43}
  44
  45/* This function is surprisingly simple.  The trick is understanding
  46 * that "child" is always a directory. So, to find its parent, you
  47 * simply need to find its ".." entry, normalize its block and offset,
  48 * and return the underlying inode.  See the comments for
  49 * isofs_normalize_block_and_offset(). */
  50static struct dentry *isofs_export_get_parent(struct dentry *child)
  51{
  52        unsigned long parent_block = 0;
  53        unsigned long parent_offset = 0;
  54        struct inode *child_inode = child->d_inode;
  55        struct iso_inode_info *e_child_inode = ISOFS_I(child_inode);
  56        struct inode *parent_inode = NULL;
  57        struct iso_directory_record *de = NULL;
  58        struct buffer_head * bh = NULL;
  59        struct dentry *rv = NULL;
  60
  61        /* "child" must always be a directory. */
  62        if (!S_ISDIR(child_inode->i_mode)) {
  63                printk(KERN_ERR "isofs: isofs_export_get_parent(): "
  64                       "child is not a directory!\n");
  65                rv = ERR_PTR(-EACCES);
  66                goto out;
  67        }
  68
  69        /* It is an invariant that the directory offset is zero.  If
  70         * it is not zero, it means the directory failed to be
  71         * normalized for some reason. */
  72        if (e_child_inode->i_iget5_offset != 0) {
  73                printk(KERN_ERR "isofs: isofs_export_get_parent(): "
  74                       "child directory not normalized!\n");
  75                rv = ERR_PTR(-EACCES);
  76                goto out;
  77        }
  78
  79        /* The child inode has been normalized such that its
  80         * i_iget5_block value points to the "." entry.  Fortunately,
  81         * the ".." entry is located in the same block. */
  82        parent_block = e_child_inode->i_iget5_block;
  83
  84        /* Get the block in question. */
  85        bh = sb_bread(child_inode->i_sb, parent_block);
  86        if (bh == NULL) {
  87                rv = ERR_PTR(-EACCES);
  88                goto out;
  89        }
  90
  91        /* This is the "." entry. */
  92        de = (struct iso_directory_record*)bh->b_data;
  93
  94        /* The ".." entry is always the second entry. */
  95        parent_offset = (unsigned long)isonum_711(de->length);
  96        de = (struct iso_directory_record*)(bh->b_data + parent_offset);
  97
  98        /* Verify it is in fact the ".." entry. */
  99        if ((isonum_711(de->name_len) != 1) || (de->name[0] != 1)) {
 100                printk(KERN_ERR "isofs: Unable to find the \"..\" "
 101                       "directory for NFS.\n");
 102                rv = ERR_PTR(-EACCES);
 103                goto out;
 104        }
 105
 106        /* Normalize */
 107        isofs_normalize_block_and_offset(de, &parent_block, &parent_offset);
 108
 109        /* Get the inode. */
 110        parent_inode = isofs_iget(child_inode->i_sb,
 111                                  parent_block,
 112                                  parent_offset);
 113        if (parent_inode == NULL) {
 114                rv = ERR_PTR(-EACCES);
 115                goto out;
 116        }
 117
 118        /* Allocate the dentry. */
 119        rv = d_alloc_anon(parent_inode);
 120        if (rv == NULL) {
 121                rv = ERR_PTR(-ENOMEM);
 122                goto out;
 123        }
 124
 125 out:
 126        if (bh) {
 127                brelse(bh);
 128        }
 129        return rv;
 130}
 131
 132static int
 133isofs_export_encode_fh(struct dentry *dentry,
 134                       __u32 *fh32,
 135                       int *max_len,
 136                       int connectable)
 137{
 138        struct inode * inode = dentry->d_inode;
 139        struct iso_inode_info * ei = ISOFS_I(inode);
 140        int len = *max_len;
 141        int type = 1;
 142        __u16 *fh16 = (__u16*)fh32;
 143
 144        /*
 145         * WARNING: max_len is 5 for NFSv2.  Because of this
 146         * limitation, we use the lower 16 bits of fh32[1] to hold the
 147         * offset of the inode and the upper 16 bits of fh32[1] to
 148         * hold the offset of the parent.
 149         */
 150
 151        if (len < 3 || (connectable && len < 5))
 152                return 255;
 153
 154        len = 3;
 155        fh32[0] = ei->i_iget5_block;
 156        fh16[2] = (__u16)ei->i_iget5_offset;  /* fh16 [sic] */
 157        fh32[2] = inode->i_generation;
 158        if (connectable && !S_ISDIR(inode->i_mode)) {
 159                struct inode *parent;
 160                struct iso_inode_info *eparent;
 161                spin_lock(&dentry->d_lock);
 162                parent = dentry->d_parent->d_inode;
 163                eparent = ISOFS_I(parent);
 164                fh32[3] = eparent->i_iget5_block;
 165                fh16[3] = (__u16)eparent->i_iget5_offset;  /* fh16 [sic] */
 166                fh32[4] = parent->i_generation;
 167                spin_unlock(&dentry->d_lock);
 168                len = 5;
 169                type = 2;
 170        }
 171        *max_len = len;
 172        return type;
 173}
 174
 175struct isofs_fid {
 176        u32 block;
 177        u16 offset;
 178        u16 parent_offset;
 179        u32 generation;
 180        u32 parent_block;
 181        u32 parent_generation;
 182};
 183
 184static struct dentry *isofs_fh_to_dentry(struct super_block *sb,
 185        struct fid *fid, int fh_len, int fh_type)
 186{
 187        struct isofs_fid *ifid = (struct isofs_fid *)fid;
 188
 189        if (fh_len < 3 || fh_type > 2)
 190                return NULL;
 191
 192        return isofs_export_iget(sb, ifid->block, ifid->offset,
 193                        ifid->generation);
 194}
 195
 196static struct dentry *isofs_fh_to_parent(struct super_block *sb,
 197                struct fid *fid, int fh_len, int fh_type)
 198{
 199        struct isofs_fid *ifid = (struct isofs_fid *)fid;
 200
 201        if (fh_type != 2)
 202                return NULL;
 203
 204        return isofs_export_iget(sb,
 205                        fh_len > 2 ? ifid->parent_block : 0,
 206                        ifid->parent_offset,
 207                        fh_len > 4 ? ifid->parent_generation : 0);
 208}
 209
 210const struct export_operations isofs_export_ops = {
 211        .encode_fh      = isofs_export_encode_fh,
 212        .fh_to_dentry   = isofs_fh_to_dentry,
 213        .fh_to_parent   = isofs_fh_to_parent,
 214        .get_parent     = isofs_export_get_parent,
 215};
 216