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
  18 static struct dentry *
  19 isofs_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 (IS_ERR(inode))
  30                 return ERR_CAST(inode);
  31         if (generation && inode->i_generation != generation) {
  32                 iput(inode);
  33                 return ERR_PTR(-ESTALE);
  34         }
  35         result = d_alloc_anon(inode);
  36         if (!result) {
  37                 iput(inode);
  38                 return ERR_PTR(-ENOMEM);
  39         }
  40         return result;
  41 }
  42
  43 /* This function is surprisingly simple.  The trick is understanding
  44  * that "child" is always a directory. So, to find its parent, you
  45  * simply need to find its ".." entry, normalize its block and offset,
  46  * and return the underlying inode.  See the comments for
  47  * isofs_normalize_block_and_offset(). */
  48 static struct dentry *isofs_export_get_parent(struct dentry *child)
  49 {
  50         unsigned long parent_block = 0;
  51         unsigned long parent_offset = 0;
  52         struct inode *child_inode = child->d_inode;
  53         struct iso_inode_info *e_child_inode = ISOFS_I(child_inode);
  54         struct inode *parent_inode = NULL;
  55         struct iso_directory_record *de = NULL;
  56         struct buffer_head * bh = NULL;
  57         struct dentry *rv = NULL;
  58
  59         /* "child" must always be a directory. */
  60         if (!S_ISDIR(child_inode->i_mode)) {
  61                 printk(KERN_ERR "isofs: isofs_export_get_parent(): "
  62                        "child is not a directory!\n");
  63                 rv = ERR_PTR(-EACCES);
  64                 goto out;
  65         }
  66
  67         /* It is an invariant that the directory offset is zero.  If
  68          * it is not zero, it means the directory failed to be
  69          * normalized for some reason. */
  70         if (e_child_inode->i_iget5_offset != 0) {
  71                 printk(KERN_ERR "isofs: isofs_export_get_parent(): "
  72                        "child directory not normalized!\n");
  73                 rv = ERR_PTR(-EACCES);
  74                 goto out;
  75         }
  76
  77         /* The child inode has been normalized such that its
  78          * i_iget5_block value points to the "." entry.  Fortunately,
  79          * the ".." entry is located in the same block. */
  80         parent_block = e_child_inode->i_iget5_block;
  81
  82         /* Get the block in question. */
  83         bh = sb_bread(child_inode->i_sb, parent_block);
  84         if (bh == NULL) {
  85                 rv = ERR_PTR(-EACCES);
  86                 goto out;
  87         }
  88
  89         /* This is the "." entry. */
  90         de = (struct iso_directory_record*)bh->b_data;
  91
  92         /* The ".." entry is always the second entry. */
  93         parent_offset = (unsigned long)isonum_711(de->length);
  94         de = (struct iso_directory_record*)(bh->b_data + parent_offset);
  95
  96         /* Verify it is in fact the ".." entry. */
  97         if ((isonum_711(de->name_len) != 1) || (de->name[0] != 1)) {
  98                 printk(KERN_ERR "isofs: Unable to find the \"..\" "
  99                        "directory for NFS.\n");
 100                 rv = ERR_PTR(-EACCES);
 101                 goto out;
 102         }
 103
 104         /* Normalize */
 105         isofs_normalize_block_and_offset(de, &parent_block, &parent_offset);
 106
 107         /* Get the inode. */
 108         parent_inode = isofs_iget(child_inode->i_sb,
 109                                   parent_block,
 110                                   parent_offset);
 111         if (IS_ERR(parent_inode)) {
 112                 rv = ERR_CAST(parent_inode);
 113                 if (rv != ERR_PTR(-ENOMEM))
 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
 132 static int
 133 isofs_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
 175 struct 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
 184 static 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
 196 static 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
 210 const 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 };