lustre/llite/llite_nfs.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.gnu.org/licenses/gpl-2.0.html
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * Copyright (c) 2011, 2017, Intel Corporation.
  27  */
  28 /*
  29  * This file is part of Lustre, http://www.lustre.org/
  30  *
  31  * lustre/lustre/llite/llite_nfs.c
  32  *
  33  * NFS export of Lustre Light File System
  34  *
  35  * Author: Yury Umanets <umka@clusterfs.com>
  36  * Author: Huang Hua <huanghua@clusterfs.com>
  37  */
  38
  39 #define DEBUG_SUBSYSTEM S_LLITE
  40 #include "llite_internal.h"
  41 #include <linux/exportfs.h>
  42
  43 u32 get_uuid2int(const char *name, int len)
  44 {
  45         u32 key0 = 0x12a3fe2d, key1 = 0x37abe8f9;
  46
  47         while (len--) {
  48                 u32 key = key1 + (key0 ^ (*name++ * 7152373));
  49
  50                 if (key & 0x80000000)
  51                         key -= 0x7fffffff;
  52
  53                 key1 = key0;
  54                 key0 = key;
  55         }
  56         return (key0 << 1);
  57 }
  58
  59 struct inode *search_inode_for_lustre(struct super_block *sb,
  60                                       const struct lu_fid *fid)
  61 {
  62         struct ll_sb_info *sbi = ll_s2sbi(sb);
  63         struct ptlrpc_request *req = NULL;
  64         struct inode *inode = NULL;
  65         int eadatalen = 0;
  66         unsigned long hash = cl_fid_build_ino(fid, ll_need_32bit_api(sbi));
  67         struct md_op_data *op_data;
  68         int rc;
  69
  70         ENTRY;
  71
  72         CDEBUG(D_INFO, "searching inode for:(%lu,"DFID")\n", hash, PFID(fid));
  73
  74         inode = ilookup5(sb, hash, ll_test_inode_by_fid, (void *)fid);
  75         if (inode)
  76                 RETURN(inode);
  77
  78         rc = ll_get_default_mdsize(sbi, &eadatalen);
  79         if (rc)
  80                 RETURN(ERR_PTR(rc));
  81
  82         /*
  83          * Because inode is NULL, ll_prep_md_op_data can not
  84          * be used here. So we allocate op_data ourselves
  85          */
  86         OBD_ALLOC_PTR(op_data);
  87         if (!op_data)
  88                 return ERR_PTR(-ENOMEM);
  89
  90         op_data->op_fid1 = *fid;
  91         op_data->op_mode = eadatalen;
  92         op_data->op_valid = OBD_MD_FLEASIZE;
  93
  94         /* mds_fid2dentry ignores f_type */
  95         rc = md_getattr(sbi->ll_md_exp, op_data, &req);
  96         OBD_FREE_PTR(op_data);
  97         if (rc) {
  98                 /*
  99                  * Suppress erroneous/confusing messages when NFS
 100                  * is out of sync and requests old data.
 101                  */
 102                 CDEBUG(D_INFO, "can't get object attrs, fid "DFID", rc %d\n",
 103                                 PFID(fid), rc);
 104                 RETURN(ERR_PTR(rc));
 105         }
 106         rc = ll_prep_inode(&inode, req, sb, NULL);
 107         ptlrpc_req_finished(req);
 108         if (rc)
 109                 RETURN(ERR_PTR(rc));
 110
 111         RETURN(inode);
 112 }
 113
 114 static struct dentry *
 115 ll_iget_for_nfs(struct super_block *sb, struct lu_fid *fid, struct lu_fid *parent)
 116 {
 117         struct inode  *inode;
 118         struct dentry *result;
 119
 120         ENTRY;
 121
 122         if (!fid_is_sane(fid))
 123                 RETURN(ERR_PTR(-ESTALE));
 124
 125         CDEBUG(D_INFO, "Get dentry for fid: "DFID"\n", PFID(fid));
 126
 127         inode = search_inode_for_lustre(sb, fid);
 128         if (IS_ERR(inode))
 129                 RETURN(ERR_CAST(inode));
 130
 131         if (is_bad_inode(inode)) {
 132                 /* we didn't find the right inode.. */
 133                 iput(inode);
 134                 RETURN(ERR_PTR(-ESTALE));
 135         }
 136
 137         /* N.B. d_obtain_alias() drops inode ref on error */
 138         result = d_obtain_alias(inode);
 139         if (!IS_ERR(result)) {
 140                 int rc;
 141
 142                 rc = ll_d_init(result);
 143                 if (rc < 0) {
 144                         dput(result);
 145                         result = ERR_PTR(rc);
 146                 } else {
 147                         struct ll_dentry_data *ldd = ll_d2d(result);
 148
 149                         /*
 150                          * Need to signal to the ll_file_open that
 151                          * we came from NFS and so opencache needs to be
 152                          * enabled for this one
 153                          */
 154                         spin_lock(&result->d_lock);
 155                         ldd->lld_nfs_dentry = 1;
 156                         spin_unlock(&result->d_lock);
 157                 }
 158         }
 159
 160         RETURN(result);
 161 }
 162
 163 #ifndef FILEID_INVALID
 164 #define FILEID_INVALID 0xff
 165 #endif
 166 #ifndef FILEID_LUSTRE
 167 #define FILEID_LUSTRE  0x97
 168 #endif
 169
 170 /**
 171  * \a connectable - is nfsd will connect himself or this should be done
 172  *                  at lustre
 173  *
 174  * The return value is file handle type:
 175  * 1 -- contains child file handle;
 176  * 2 -- contains child file handle and parent file handle;
 177  * 255 -- error.
 178  */
 179 static int ll_encode_fh(struct inode *inode, u32 *fh, int *plen,
 180                         struct inode *parent)
 181 {
 182         int fileid_len = sizeof(struct lustre_file_handle) / 4;
 183         struct lustre_file_handle *lfh = (void *)fh;
 184
 185         ENTRY;
 186
 187         CDEBUG(D_INFO, "%s: encoding for ("DFID") maxlen=%d minlen=%d\n",
 188                ll_i2sbi(inode)->ll_fsname,
 189                PFID(ll_inode2fid(inode)), *plen, fileid_len);
 190
 191         if (*plen < fileid_len) {
 192                 *plen = fileid_len;
 193                 RETURN(FILEID_INVALID);
 194         }
 195
 196         lfh->lfh_child = *ll_inode2fid(inode);
 197         if (parent)
 198                 lfh->lfh_parent = *ll_inode2fid(parent);
 199         else
 200                 fid_zero(&lfh->lfh_parent);
 201         *plen = fileid_len;
 202
 203         RETURN(FILEID_LUSTRE);
 204 }
 205
 206 static int
 207 #ifndef HAVE_FILLDIR_USE_CTX
 208 ll_nfs_get_name_filldir(void *cookie, const char *name, int namelen,
 209                         loff_t hash, u64 ino, unsigned type)
 210 {
 211         struct ll_getname_data *lgd = cookie;
 212 #else
 213 ll_nfs_get_name_filldir(struct dir_context *ctx, const char *name, int namelen,
 214                         loff_t hash, u64 ino, unsigned type)
 215 {
 216         struct ll_getname_data *lgd =
 217                 container_of(ctx, struct ll_getname_data, ctx);
 218 #endif /* HAVE_FILLDIR_USE_CTX */
 219         /*
 220          * It is hack to access lde_fid for comparison with lgd_fid.
 221          * So the input 'name' must be part of the 'lu_dirent', and
 222          * so must appear to be a non-const pointer to an empty array.
 223          */
 224         char (*n)[0] = (void *)name;
 225         /* NOTE: This should be container_of().  However container_of() in
 226          * kernels earlier than v4.13-rc1~37^2~94 cause this to generate a
 227          * warning, which fails when we compile with -Werror.  Those earlier
 228          * kernels don't have container_of_safe, calling that instead will use
 229          * the lustre-local version which doesn't generate the warning.
 230          */
 231         struct lu_dirent *lde = container_of_safe(n, struct lu_dirent, lde_name);
 232         struct lu_fid fid;
 233
 234         fid_le_to_cpu(&fid, &lde->lde_fid);
 235         if (lu_fid_eq(&fid, &lgd->lgd_fid)) {
 236                 memcpy(lgd->lgd_name, name, namelen);
 237                 lgd->lgd_name[namelen] = 0;
 238                 lgd->lgd_found = 1;
 239         }
 240         return lgd->lgd_found;
 241 }
 242
 243 static int ll_get_name(struct dentry *dentry, char *name,
 244                        struct dentry *child)
 245 {
 246         struct inode *dir = dentry->d_inode;
 247         struct ll_getname_data lgd = {
 248                 .lgd_name = name,
 249                 .lgd_fid = ll_i2info(child->d_inode)->lli_fid,
 250 #ifdef HAVE_DIR_CONTEXT
 251                 .ctx.actor = ll_nfs_get_name_filldir,
 252 #endif
 253                 .lgd_found = 0,
 254         };
 255         struct md_op_data *op_data;
 256         u64 pos = 0;
 257         int rc;
 258
 259         ENTRY;
 260
 261         if (!dir || !S_ISDIR(dir->i_mode))
 262                 GOTO(out, rc = -ENOTDIR);
 263
 264         if (!dir->i_fop)
 265                 GOTO(out, rc = -EINVAL);
 266
 267         op_data = ll_prep_md_op_data(NULL, dir, dir, NULL, 0, 0,
 268                                      LUSTRE_OPC_ANY, dir);
 269         if (IS_ERR(op_data))
 270                 GOTO(out, rc = PTR_ERR(op_data));
 271
 272         inode_lock(dir);
 273 #ifdef HAVE_DIR_CONTEXT
 274         rc = ll_dir_read(dir, &pos, op_data, &lgd.ctx);
 275 #else
 276         rc = ll_dir_read(dir, &pos, op_data, &lgd, ll_nfs_get_name_filldir);
 277 #endif
 278         inode_unlock(dir);
 279         ll_finish_md_op_data(op_data);
 280         if (!rc && !lgd.lgd_found)
 281                 rc = -ENOENT;
 282         EXIT;
 283 out:
 284         return rc;
 285 }
 286
 287 static struct dentry *ll_fh_to_dentry(struct super_block *sb, struct fid *fid,
 288                                       int fh_len, int fh_type)
 289 {
 290         struct lustre_file_handle *lfh = (struct lustre_file_handle *)fid;
 291
 292         if (fh_type != FILEID_LUSTRE)
 293                 RETURN(ERR_PTR(-EPROTO));
 294
 295         RETURN(ll_iget_for_nfs(sb, &lfh->lfh_child, &lfh->lfh_parent));
 296 }
 297
 298 static struct dentry *ll_fh_to_parent(struct super_block *sb, struct fid *fid,
 299                                       int fh_len, int fh_type)
 300 {
 301         struct lustre_file_handle *lfh = (struct lustre_file_handle *)fid;
 302
 303         if (fh_type != FILEID_LUSTRE)
 304                 RETURN(ERR_PTR(-EPROTO));
 305
 306         RETURN(ll_iget_for_nfs(sb, &lfh->lfh_parent, NULL));
 307 }
 308
 309 int ll_dir_get_parent_fid(struct inode *dir, struct lu_fid *parent_fid)
 310 {
 311         struct ptlrpc_request   *req = NULL;
 312         struct ll_sb_info       *sbi;
 313         struct mdt_body         *body;
 314         static const char       dotdot[] = "..";
 315         struct md_op_data       *op_data;
 316         int                     rc;
 317         int                     lmmsize;
 318
 319         ENTRY;
 320
 321         LASSERT(dir && S_ISDIR(dir->i_mode));
 322
 323         sbi = ll_s2sbi(dir->i_sb);
 324
 325         CDEBUG(D_INFO, "%s: getting parent for ("DFID")\n",
 326                sbi->ll_fsname, PFID(ll_inode2fid(dir)));
 327
 328         rc = ll_get_default_mdsize(sbi, &lmmsize);
 329         if (rc != 0)
 330                 RETURN(rc);
 331
 332         op_data = ll_prep_md_op_data(NULL, dir, NULL, dotdot,
 333                                      strlen(dotdot), lmmsize,
 334                                      LUSTRE_OPC_ANY, NULL);
 335         if (IS_ERR(op_data))
 336                 RETURN(PTR_ERR(op_data));
 337
 338         rc = md_getattr_name(sbi->ll_md_exp, op_data, &req);
 339         ll_finish_md_op_data(op_data);
 340         if (rc != 0) {
 341                 CERROR("%s: failure inode "DFID" get parent: rc = %d\n",
 342                        sbi->ll_fsname, PFID(ll_inode2fid(dir)), rc);
 343                 RETURN(rc);
 344         }
 345         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
 346
 347         /*
 348          * LU-3952: MDT may lost the FID of its parent, we should not crash
 349          * the NFS server, ll_iget_for_nfs() will handle the error.
 350          */
 351         if (body->mbo_valid & OBD_MD_FLID) {
 352                 CDEBUG(D_INFO, "parent for "DFID" is "DFID"\n",
 353                        PFID(ll_inode2fid(dir)), PFID(&body->mbo_fid1));
 354                 *parent_fid = body->mbo_fid1;
 355         }
 356
 357         ptlrpc_req_finished(req);
 358         RETURN(0);
 359 }
 360
 361 static struct dentry *ll_get_parent(struct dentry *dchild)
 362 {
 363         struct lu_fid parent_fid = { 0 };
 364         int rc;
 365         struct dentry *dentry;
 366
 367         ENTRY;
 368
 369         rc = ll_dir_get_parent_fid(dchild->d_inode, &parent_fid);
 370         if (rc != 0)
 371                 RETURN(ERR_PTR(rc));
 372
 373         dentry = ll_iget_for_nfs(dchild->d_inode->i_sb, &parent_fid, NULL);
 374
 375         RETURN(dentry);
 376 }
 377
 378 const struct export_operations lustre_export_operations = {
 379         .get_parent = ll_get_parent,
 380         .encode_fh  = ll_encode_fh,
 381         .get_name   = ll_get_name,
 382         .fh_to_dentry = ll_fh_to_dentry,
 383         .fh_to_parent = ll_fh_to_parent,
 384 };