lustre/mdt/mdt_lvb.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, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 021110-1307, USA
  20  *
  21  * GPL HEADER END
  22  */
  23 /*
  24  * Copyright (c) 2012, Intel Corporation.
  25  * Use is subject to license terms.
  26  *
  27  * lustre/mdt/mdt_lvb.c
  28  *
  29  * Author: Jinshan Xiong <jinshan.xiong@intel.com>
  30  */
  31
  32 #define DEBUG_SUBSYSTEM S_MDS
  33
  34 #include "mdt_internal.h"
  35
  36 /* Called with res->lr_lvb_sem held */
  37 static int mdt_lvbo_init(struct ldlm_resource *res)
  38 {
  39         if (IS_LQUOTA_RES(res)) {
  40                 struct mdt_device       *mdt;
  41
  42                 mdt = ldlm_res_to_ns(res)->ns_lvbp;
  43                 if (mdt->mdt_qmt_dev == NULL)
  44                         return 0;
  45
  46                 /* call lvbo init function of quota master */
  47                 return qmt_hdls.qmth_lvbo_init(mdt->mdt_qmt_dev, res);
  48         }
  49
  50         return 0;
  51 }
  52
  53 static int mdt_lvbo_update(struct ldlm_resource *res,
  54                            struct ptlrpc_request *req,
  55                            int increase_only)
  56 {
  57         if (IS_LQUOTA_RES(res)) {
  58                 struct mdt_device       *mdt;
  59
  60                 mdt = ldlm_res_to_ns(res)->ns_lvbp;
  61                 if (mdt->mdt_qmt_dev == NULL)
  62                         return 0;
  63
  64                 /* call lvbo update function of quota master */
  65                 return qmt_hdls.qmth_lvbo_update(mdt->mdt_qmt_dev, res, req,
  66                                                  increase_only);
  67         }
  68
  69         return 0;
  70 }
  71
  72
  73 static int mdt_lvbo_size(struct ldlm_lock *lock)
  74 {
  75         struct mdt_device *mdt;
  76
  77         /* resource on server side never changes. */
  78         mdt = ldlm_res_to_ns(lock->l_resource)->ns_lvbp;
  79         LASSERT(mdt != NULL);
  80
  81         if (IS_LQUOTA_RES(lock->l_resource)) {
  82                 if (mdt->mdt_qmt_dev == NULL)
  83                         return 0;
  84
  85                 /* call lvbo size function of quota master */
  86                 return qmt_hdls.qmth_lvbo_size(mdt->mdt_qmt_dev, lock);
  87         }
  88
  89         if (ldlm_has_layout(lock))
  90                 return mdt->mdt_max_mdsize;
  91
  92         return 0;
  93 }
  94
  95 static int mdt_lvbo_fill(struct ldlm_lock *lock, void *lvb, int lvblen)
  96 {
  97         struct lu_env env;
  98         struct mdt_thread_info *info;
  99         struct mdt_device *mdt;
 100         struct lu_fid *fid;
 101         struct mdt_object *obj = NULL;
 102         struct md_object *child = NULL;
 103         int rc;
 104         ENTRY;
 105
 106         mdt = ldlm_lock_to_ns(lock)->ns_lvbp;
 107         if (IS_LQUOTA_RES(lock->l_resource)) {
 108                 if (mdt->mdt_qmt_dev == NULL)
 109                         RETURN(0);
 110
 111                 /* call lvbo fill function of quota master */
 112                 rc = qmt_hdls.qmth_lvbo_fill(mdt->mdt_qmt_dev, lock, lvb,
 113                                              lvblen);
 114                 RETURN(rc);
 115         }
 116
 117         if (lock->l_resource->lr_type != LDLM_IBITS ||
 118                 !(lock->l_policy_data.l_inodebits.bits & MDS_INODELOCK_LAYOUT))
 119                 RETURN(0);
 120
 121         /* layout lock will be granted to client, fill in lvb with layout */
 122
 123         /* XXX create an env to talk to mdt stack. We should get this env from
 124          * ptlrpc_thread->t_env. */
 125         rc = lu_env_init(&env, LCT_MD_THREAD);
 126         LASSERT(rc == 0);
 127
 128         info = lu_context_key_get(&env.le_ctx, &mdt_thread_key);
 129         LASSERT(info != NULL);
 130         memset(info, 0, sizeof *info);
 131         info->mti_env = &env;
 132         info->mti_exp = lock->l_export;
 133         info->mti_mdt = mdt;
 134
 135         /* XXX get fid by resource id. why don't include fid in ldlm_resource */
 136         fid = &info->mti_tmp_fid2;
 137         fid_build_from_res_name(fid, &lock->l_resource->lr_name);
 138
 139         obj = mdt_object_find(&env, info->mti_mdt, fid);
 140         if (IS_ERR(obj))
 141                 GOTO(out, rc = PTR_ERR(obj));
 142
 143         if (!mdt_object_exists(obj) || mdt_object_remote(obj))
 144                 GOTO(out, rc = -ENOENT);
 145
 146         child = mdt_object_child(obj);
 147
 148         /* get the length of lsm */
 149         rc = mo_xattr_get(&env, child, &LU_BUF_NULL, XATTR_NAME_LOV);
 150         if (rc < 0)
 151                 GOTO(out, rc);
 152
 153         if (rc > 0) {
 154                 struct lu_buf *lmm = NULL;
 155
 156                 if (lvblen < rc) {
 157                         CERROR("%s: expected %d actual %d.\n",
 158                                 info->mti_exp->exp_obd->obd_name, rc, lvblen);
 159                         GOTO(out, rc = -ERANGE);
 160                 }
 161
 162                 lmm = &info->mti_buf;
 163                 lmm->lb_buf = lvb;
 164                 lmm->lb_len = rc;
 165
 166                 rc = mo_xattr_get(&env, child, lmm, XATTR_NAME_LOV);
 167                 if (rc < 0)
 168                         GOTO(out, rc);
 169         }
 170
 171 out:
 172         if (obj != NULL && !IS_ERR(obj))
 173                 mdt_object_put(&env, obj);
 174         lu_env_fini(&env);
 175         RETURN(rc < 0 ? 0 : rc);
 176 }
 177
 178 static int mdt_lvbo_free(struct ldlm_resource *res)
 179 {
 180         if (IS_LQUOTA_RES(res)) {
 181                 struct mdt_device       *mdt;
 182
 183                 mdt = ldlm_res_to_ns(res)->ns_lvbp;
 184                 if (mdt->mdt_qmt_dev == NULL)
 185                         return 0;
 186
 187                 /* call lvbo free function of quota master */
 188                 return qmt_hdls.qmth_lvbo_free(mdt->mdt_qmt_dev, res);
 189         }
 190
 191         return 0;
 192 }
 193
 194 struct ldlm_valblock_ops mdt_lvbo = {
 195         lvbo_init:      mdt_lvbo_init,
 196         lvbo_update:    mdt_lvbo_update,
 197         lvbo_size:      mdt_lvbo_size,
 198         lvbo_fill:      mdt_lvbo_fill,
 199         lvbo_free:      mdt_lvbo_free
 200 };