fs/ceph/export.c

   1 #include <linux/ceph/ceph_debug.h>
   2
   3 #include <linux/exportfs.h>
   4 #include <linux/slab.h>
   5 #include <asm/unaligned.h>
   6
   7 #include "super.h"
   8 #include "mds_client.h"
   9
  10 /*
  11  * NFS export support
  12  *
  13  * NFS re-export of a ceph mount is, at present, only semireliable.
  14  * The basic issue is that the Ceph architectures doesn't lend itself
  15  * well to generating filehandles that will remain valid forever.
  16  *
  17  * So, we do our best.  If you're lucky, your inode will be in the
  18  * client's cache.  If it's not, and you have a connectable fh, then
  19  * the MDS server may be able to find it for you.  Otherwise, you get
  20  * ESTALE.
  21  *
  22  * There are ways to this more reliable, but in the non-connectable fh
  23  * case, we won't every work perfectly, and in the connectable case,
  24  * some changes are needed on the MDS side to work better.
  25  */
  26
  27 /*
  28  * Basic fh
  29  */
  30 struct ceph_nfs_fh {
  31         u64 ino;
  32 } __attribute__ ((packed));
  33
  34 /*
  35  * Larger 'connectable' fh that includes parent ino and name hash.
  36  * Use this whenever possible, as it works more reliably.
  37  */
  38 struct ceph_nfs_confh {
  39         u64 ino, parent_ino;
  40         u32 parent_name_hash;
  41 } __attribute__ ((packed));
  42
  43 static int ceph_encode_fh(struct dentry *dentry, u32 *rawfh, int *max_len,
  44                           int connectable)
  45 {
  46         int type;
  47         struct ceph_nfs_fh *fh = (void *)rawfh;
  48         struct ceph_nfs_confh *cfh = (void *)rawfh;
  49         struct dentry *parent = dentry->d_parent;
  50         struct inode *inode = dentry->d_inode;
  51         int connected_handle_length = sizeof(*cfh)/4;
  52         int handle_length = sizeof(*fh)/4;
  53
  54         /* don't re-export snaps */
  55         if (ceph_snap(inode) != CEPH_NOSNAP)
  56                 return -EINVAL;
  57
  58         if (*max_len >= connected_handle_length) {
  59                 dout("encode_fh %p connectable\n", dentry);
  60                 cfh->ino = ceph_ino(dentry->d_inode);
  61                 cfh->parent_ino = ceph_ino(parent->d_inode);
  62                 cfh->parent_name_hash = ceph_dentry_hash(parent);
  63                 *max_len = connected_handle_length;
  64                 type = 2;
  65         } else if (*max_len >= handle_length) {
  66                 if (connectable) {
  67                         *max_len = connected_handle_length;
  68                         return 255;
  69                 }
  70                 dout("encode_fh %p\n", dentry);
  71                 fh->ino = ceph_ino(dentry->d_inode);
  72                 *max_len = handle_length;
  73                 type = 1;
  74         } else {
  75                 *max_len = handle_length;
  76                 return 255;
  77         }
  78         return type;
  79 }
  80
  81 /*
  82  * convert regular fh to dentry
  83  *
  84  * FIXME: we should try harder by querying the mds for the ino.
  85  */
  86 static struct dentry *__fh_to_dentry(struct super_block *sb,
  87                                      struct ceph_nfs_fh *fh)
  88 {
  89         struct inode *inode;
  90         struct dentry *dentry;
  91         struct ceph_vino vino;
  92         int err;
  93
  94         dout("__fh_to_dentry %llx\n", fh->ino);
  95         vino.ino = fh->ino;
  96         vino.snap = CEPH_NOSNAP;
  97         inode = ceph_find_inode(sb, vino);
  98         if (!inode)
  99                 return ERR_PTR(-ESTALE);
 100
 101         dentry = d_obtain_alias(inode);
 102         if (IS_ERR(dentry)) {
 103                 pr_err("fh_to_dentry %llx -- inode %p but ENOMEM\n",
 104                        fh->ino, inode);
 105                 iput(inode);
 106                 return dentry;
 107         }
 108         err = ceph_init_dentry(dentry);
 109
 110         if (err < 0) {
 111                 iput(inode);
 112                 return ERR_PTR(err);
 113         }
 114         dout("__fh_to_dentry %llx %p dentry %p\n", fh->ino, inode, dentry);
 115         return dentry;
 116 }
 117
 118 /*
 119  * convert connectable fh to dentry
 120  */
 121 static struct dentry *__cfh_to_dentry(struct super_block *sb,
 122                                       struct ceph_nfs_confh *cfh)
 123 {
 124         struct ceph_mds_client *mdsc = ceph_sb_to_client(sb)->mdsc;
 125         struct inode *inode;
 126         struct dentry *dentry;
 127         struct ceph_vino vino;
 128         int err;
 129
 130         dout("__cfh_to_dentry %llx (%llx/%x)\n",
 131              cfh->ino, cfh->parent_ino, cfh->parent_name_hash);
 132
 133         vino.ino = cfh->ino;
 134         vino.snap = CEPH_NOSNAP;
 135         inode = ceph_find_inode(sb, vino);
 136         if (!inode) {
 137                 struct ceph_mds_request *req;
 138
 139                 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPHASH,
 140                                                USE_ANY_MDS);
 141                 if (IS_ERR(req))
 142                         return ERR_CAST(req);
 143
 144                 req->r_ino1 = vino;
 145                 req->r_ino2.ino = cfh->parent_ino;
 146                 req->r_ino2.snap = CEPH_NOSNAP;
 147                 req->r_path2 = kmalloc(16, GFP_NOFS);
 148                 snprintf(req->r_path2, 16, "%d", cfh->parent_name_hash);
 149                 req->r_num_caps = 1;
 150                 err = ceph_mdsc_do_request(mdsc, NULL, req);
 151                 ceph_mdsc_put_request(req);
 152                 inode = ceph_find_inode(sb, vino);
 153                 if (!inode)
 154                         return ERR_PTR(err ? err : -ESTALE);
 155         }
 156
 157         dentry = d_obtain_alias(inode);
 158         if (IS_ERR(dentry)) {
 159                 pr_err("cfh_to_dentry %llx -- inode %p but ENOMEM\n",
 160                        cfh->ino, inode);
 161                 iput(inode);
 162                 return dentry;
 163         }
 164         err = ceph_init_dentry(dentry);
 165         if (err < 0) {
 166                 iput(inode);
 167                 return ERR_PTR(err);
 168         }
 169         dout("__cfh_to_dentry %llx %p dentry %p\n", cfh->ino, inode, dentry);
 170         return dentry;
 171 }
 172
 173 static struct dentry *ceph_fh_to_dentry(struct super_block *sb, struct fid *fid,
 174                                         int fh_len, int fh_type)
 175 {
 176         if (fh_type == 1)
 177                 return __fh_to_dentry(sb, (struct ceph_nfs_fh *)fid->raw);
 178         else
 179                 return __cfh_to_dentry(sb, (struct ceph_nfs_confh *)fid->raw);
 180 }
 181
 182 /*
 183  * get parent, if possible.
 184  *
 185  * FIXME: we could do better by querying the mds to discover the
 186  * parent.
 187  */
 188 static struct dentry *ceph_fh_to_parent(struct super_block *sb,
 189                                          struct fid *fid,
 190                                         int fh_len, int fh_type)
 191 {
 192         struct ceph_nfs_confh *cfh = (void *)fid->raw;
 193         struct ceph_vino vino;
 194         struct inode *inode;
 195         struct dentry *dentry;
 196         int err;
 197
 198         if (fh_type == 1)
 199                 return ERR_PTR(-ESTALE);
 200
 201         pr_debug("fh_to_parent %llx/%d\n", cfh->parent_ino,
 202                  cfh->parent_name_hash);
 203
 204         vino.ino = cfh->ino;
 205         vino.snap = CEPH_NOSNAP;
 206         inode = ceph_find_inode(sb, vino);
 207         if (!inode)
 208                 return ERR_PTR(-ESTALE);
 209
 210         dentry = d_obtain_alias(inode);
 211         if (IS_ERR(dentry)) {
 212                 pr_err("fh_to_parent %llx -- inode %p but ENOMEM\n",
 213                        cfh->ino, inode);
 214                 iput(inode);
 215                 return dentry;
 216         }
 217         err = ceph_init_dentry(dentry);
 218         if (err < 0) {
 219                 iput(inode);
 220                 return ERR_PTR(err);
 221         }
 222         dout("fh_to_parent %llx %p dentry %p\n", cfh->ino, inode, dentry);
 223         return dentry;
 224 }
 225
 226 const struct export_operations ceph_export_ops = {
 227         .encode_fh = ceph_encode_fh,
 228         .fh_to_dentry = ceph_fh_to_dentry,
 229         .fh_to_parent = ceph_fh_to_parent,
 230 };