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->rq_pill, 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                 RETURN(result);
 141
 142         if (!ll_d_setup(result, true))
 143                 RETURN(ERR_PTR(-ENOMEM));
 144
 145 #if LINUX_VERSION_CODE < KERNEL_VERSION(5, 5, 0)
 146         /* If we are called by nfsd kthread set lli_open_thrsh_count
 147          * to one. This will force caching the open lock. To be
 148          * removed once oldest supported Linux kernel is 5.5
 149          */
 150         if ((current->flags & PF_KTHREAD) &&
 151             strcmp(current->comm, "nfsd") == 0) {
 152                 struct ll_inode_info *lli = ll_i2info(inode);
 153
 154                 lli->lli_open_thrsh_count = 1;
 155         }
 156 #endif
 157         RETURN(result);
 158 }
 159
 160 #ifndef FILEID_INVALID
 161 #define FILEID_INVALID 0xff
 162 #endif
 163 #ifndef FILEID_LUSTRE
 164 #define FILEID_LUSTRE  0x97
 165 #endif
 166
 167 /**
 168  * \a connectable - is nfsd will connect himself or this should be done
 169  *                  at lustre
 170  *
 171  * The return value is file handle type:
 172  * 1 -- contains child file handle;
 173  * 2 -- contains child file handle and parent file handle;
 174  * 255 -- error.
 175  */
 176 static int ll_encode_fh(struct inode *inode, u32 *fh, int *plen,
 177                         struct inode *parent)
 178 {
 179         int fileid_len = sizeof(struct lustre_file_handle) / 4;
 180         struct lustre_file_handle *lfh = (void *)fh;
 181
 182         ENTRY;
 183
 184         CDEBUG(D_INFO, "%s: encoding for ("DFID") maxlen=%d minlen=%d\n",
 185                ll_i2sbi(inode)->ll_fsname,
 186                PFID(ll_inode2fid(inode)), *plen, fileid_len);
 187
 188         if (*plen < fileid_len) {
 189                 *plen = fileid_len;
 190                 RETURN(FILEID_INVALID);
 191         }
 192
 193         lfh->lfh_child = *ll_inode2fid(inode);
 194         if (parent)
 195                 lfh->lfh_parent = *ll_inode2fid(parent);
 196         else
 197                 fid_zero(&lfh->lfh_parent);
 198         *plen = fileid_len;
 199
 200         RETURN(FILEID_LUSTRE);
 201 }
 202
 203 static inline int
 204 do_nfs_get_name_filldir(struct ll_getname_data *lgd, const char *name,
 205                         int namelen, loff_t hash, u64 ino, unsigned int type)
 206 {
 207         /*
 208          * It is hack to access lde_fid for comparison with lgd_fid.
 209          * So the input 'name' must be part of the 'lu_dirent', and
 210          * so must appear to be a non-const pointer to an empty array.
 211          */
 212         char (*n)[0] = (void *)name;
 213         /* NOTE: This should be container_of().  However container_of() in
 214          * kernels earlier than v4.13-rc1~37^2~94 cause this to generate a
 215          * warning, which fails when we compile with -Werror.  Those earlier
 216          * kernels don't have container_of_safe, calling that instead will use
 217          * the lustre-local version which doesn't generate the warning.
 218          */
 219         struct lu_dirent *lde = container_of_safe(n, struct lu_dirent, lde_name);
 220         struct lu_fid fid;
 221
 222         fid_le_to_cpu(&fid, &lde->lde_fid);
 223         if (lu_fid_eq(&fid, &lgd->lgd_fid)) {
 224                 memcpy(lgd->lgd_name, name, namelen);
 225                 lgd->lgd_name[namelen] = 0;
 226                 lgd->lgd_found = 1;
 227         }
 228         return lgd->lgd_found;
 229 }
 230
 231 #ifdef HAVE_FILLDIR_USE_CTX_RETURN_BOOL
 232 static bool
 233 ll_nfs_get_name_filldir(struct dir_context *ctx, const char *name, int namelen,
 234                         loff_t hash, u64 ino, unsigned int type)
 235 {
 236         struct ll_getname_data *lgd =
 237                 container_of(ctx, struct ll_getname_data, ctx);
 238         int err = do_nfs_get_name_filldir(lgd, name, namelen, hash, ino, type);
 239
 240         return err == 0;
 241 }
 242 #elif defined(HAVE_FILLDIR_USE_CTX)
 243 static int
 244 ll_nfs_get_name_filldir(struct dir_context *ctx, const char *name, int namelen,
 245                         loff_t hash, u64 ino, unsigned int type)
 246 {
 247         struct ll_getname_data *lgd =
 248                 container_of(ctx, struct ll_getname_data, ctx);
 249
 250         return do_nfs_get_name_filldir(lgd, name, namelen, hash, ino, type);
 251 }
 252 #else
 253 static int ll_nfs_get_name_filldir(void *cookie, const char *name, int namelen,
 254                                    loff_t hash, u64 ino, unsigned int type)
 255 {
 256         struct ll_getname_data *lgd = cookie;
 257
 258         return do_nfs_get_name_filldir(lgd, name, namelen, hash, ino, type);
 259 }
 260 #endif /* HAVE_FILLDIR_USE_CTX */
 261
 262 static int ll_get_name(struct dentry *dentry, char *name, struct dentry *child)
 263 {
 264         struct inode *dir = dentry->d_inode;
 265         struct ll_getname_data lgd = {
 266                 .lgd_name = name,
 267                 .lgd_fid = ll_i2info(child->d_inode)->lli_fid,
 268 #ifdef HAVE_DIR_CONTEXT
 269                 .ctx.actor = (filldir_t)ll_nfs_get_name_filldir,
 270 #endif
 271                 .lgd_found = 0,
 272         };
 273         struct md_op_data *op_data;
 274         u64 pos = 0;
 275         int rc;
 276
 277         ENTRY;
 278
 279         if (!dir || !S_ISDIR(dir->i_mode))
 280                 GOTO(out, rc = -ENOTDIR);
 281
 282         if (!dir->i_fop)
 283                 GOTO(out, rc = -EINVAL);
 284
 285         op_data = ll_prep_md_op_data(NULL, dir, dir, NULL, 0, 0,
 286                                      LUSTRE_OPC_ANY, dir);
 287         if (IS_ERR(op_data))
 288                 GOTO(out, rc = PTR_ERR(op_data));
 289
 290         ll_inode_lock(dir);
 291 #ifdef HAVE_DIR_CONTEXT
 292         rc = ll_dir_read(dir, &pos, op_data, &lgd.ctx, NULL);
 293 #else
 294         rc = ll_dir_read(dir, &pos, op_data, &lgd, ll_nfs_get_name_filldir,
 295                          NULL);
 296 #endif
 297         ll_inode_unlock(dir);
 298         ll_finish_md_op_data(op_data);
 299         if (!rc && !lgd.lgd_found)
 300                 rc = -ENOENT;
 301         EXIT;
 302 out:
 303         return rc;
 304 }
 305
 306 static struct dentry *ll_fh_to_dentry(struct super_block *sb, struct fid *fid,
 307                                       int fh_len, int fh_type)
 308 {
 309         struct lustre_file_handle *lfh = (struct lustre_file_handle *)fid;
 310
 311         if (fh_type != FILEID_LUSTRE)
 312                 RETURN(ERR_PTR(-EPROTO));
 313
 314         RETURN(ll_iget_for_nfs(sb, &lfh->lfh_child, &lfh->lfh_parent));
 315 }
 316
 317 static struct dentry *ll_fh_to_parent(struct super_block *sb, struct fid *fid,
 318                                       int fh_len, int fh_type)
 319 {
 320         struct lustre_file_handle *lfh = (struct lustre_file_handle *)fid;
 321
 322         if (fh_type != FILEID_LUSTRE)
 323                 RETURN(ERR_PTR(-EPROTO));
 324
 325         RETURN(ll_iget_for_nfs(sb, &lfh->lfh_parent, NULL));
 326 }
 327
 328 int ll_dir_get_parent_fid(struct inode *dir, struct lu_fid *parent_fid)
 329 {
 330         struct ptlrpc_request   *req = NULL;
 331         struct ll_sb_info       *sbi;
 332         struct mdt_body         *body;
 333         static const char       dotdot[] = "..";
 334         struct md_op_data       *op_data;
 335         int                     rc;
 336         int                     lmmsize;
 337
 338         ENTRY;
 339
 340         LASSERT(dir && S_ISDIR(dir->i_mode));
 341
 342         sbi = ll_s2sbi(dir->i_sb);
 343
 344         CDEBUG(D_INFO, "%s: getting parent for ("DFID")\n",
 345                sbi->ll_fsname, PFID(ll_inode2fid(dir)));
 346
 347         rc = ll_get_default_mdsize(sbi, &lmmsize);
 348         if (rc != 0)
 349                 RETURN(rc);
 350
 351         op_data = ll_prep_md_op_data(NULL, dir, NULL, dotdot,
 352                                      strlen(dotdot), lmmsize,
 353                                      LUSTRE_OPC_ANY, NULL);
 354         if (IS_ERR(op_data))
 355                 RETURN(PTR_ERR(op_data));
 356
 357         rc = md_getattr_name(sbi->ll_md_exp, op_data, &req);
 358         ll_finish_md_op_data(op_data);
 359         if (rc != 0) {
 360                 CERROR("%s: failure inode "DFID" get parent: rc = %d\n",
 361                        sbi->ll_fsname, PFID(ll_inode2fid(dir)), rc);
 362                 RETURN(rc);
 363         }
 364         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
 365
 366         /*
 367          * LU-3952: MDT may lost the FID of its parent, we should not crash
 368          * the NFS server, ll_iget_for_nfs() will handle the error.
 369          */
 370         if (body->mbo_valid & OBD_MD_FLID) {
 371                 CDEBUG(D_INFO, "parent for "DFID" is "DFID"\n",
 372                        PFID(ll_inode2fid(dir)), PFID(&body->mbo_fid1));
 373                 *parent_fid = body->mbo_fid1;
 374         }
 375
 376         ptlrpc_req_finished(req);
 377         RETURN(0);
 378 }
 379
 380 static struct dentry *ll_get_parent(struct dentry *dchild)
 381 {
 382         struct lu_fid parent_fid = { 0 };
 383         int rc;
 384         struct dentry *dentry;
 385
 386         ENTRY;
 387
 388         rc = ll_dir_get_parent_fid(dchild->d_inode, &parent_fid);
 389         if (rc != 0)
 390                 RETURN(ERR_PTR(rc));
 391
 392         dentry = ll_iget_for_nfs(dchild->d_inode->i_sb, &parent_fid, NULL);
 393
 394         RETURN(dentry);
 395 }
 396
 397 const struct export_operations lustre_export_operations = {
 398         .get_parent = ll_get_parent,
 399         .encode_fh  = ll_encode_fh,
 400         .get_name   = ll_get_name,
 401         .fh_to_dentry = ll_fh_to_dentry,
 402         .fh_to_parent = ll_fh_to_parent,
 403 };