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 (!ldlm_has_layout(lock))
 118                 RETURN(0);
 119
 120         /* layout lock will be granted to client, fill in lvb with layout */
 121
 122         /* XXX create an env to talk to mdt stack. We should get this env from
 123          * ptlrpc_thread->t_env. */
 124         rc = lu_env_init(&env, LCT_MD_THREAD);
 125         LASSERT(rc == 0);
 126
 127         info = lu_context_key_get(&env.le_ctx, &mdt_thread_key);
 128         LASSERT(info != NULL);
 129         memset(info, 0, sizeof *info);
 130         info->mti_env = &env;
 131         info->mti_exp = lock->l_export;
 132         info->mti_mdt = mdt;
 133
 134         /* XXX get fid by resource id. why don't include fid in ldlm_resource */
 135         fid = &info->mti_tmp_fid2;
 136         fid_build_from_res_name(fid, &lock->l_resource->lr_name);
 137
 138         obj = mdt_object_find(&env, info->mti_mdt, fid);
 139         if (IS_ERR(obj))
 140                 GOTO(out, rc = PTR_ERR(obj));
 141
 142         if (!mdt_object_exists(obj) || mdt_object_remote(obj))
 143                 GOTO(out, rc = -ENOENT);
 144
 145         child = mdt_object_child(obj);
 146
 147         /* get the length of lsm */
 148         rc = mo_xattr_get(&env, child, &LU_BUF_NULL, XATTR_NAME_LOV);
 149         if (rc < 0)
 150                 GOTO(out, rc);
 151
 152         if (rc > 0) {
 153                 struct lu_buf *lmm = NULL;
 154
 155                 if (lvblen < rc) {
 156                         CERROR("%s: expected %d actual %d.\n",
 157                                 info->mti_exp->exp_obd->obd_name, rc, lvblen);
 158                         GOTO(out, rc = -ERANGE);
 159                 }
 160
 161                 lmm = &info->mti_buf;
 162                 lmm->lb_buf = lvb;
 163                 lmm->lb_len = rc;
 164
 165                 rc = mo_xattr_get(&env, child, lmm, XATTR_NAME_LOV);
 166                 if (rc < 0)
 167                         GOTO(out, rc);
 168         }
 169
 170 out:
 171         if (obj != NULL && !IS_ERR(obj))
 172                 mdt_object_put(&env, obj);
 173         lu_env_fini(&env);
 174         RETURN(rc < 0 ? 0 : rc);
 175 }
 176
 177 static int mdt_lvbo_free(struct ldlm_resource *res)
 178 {
 179         if (IS_LQUOTA_RES(res)) {
 180                 struct mdt_device       *mdt;
 181
 182                 mdt = ldlm_res_to_ns(res)->ns_lvbp;
 183                 if (mdt->mdt_qmt_dev == NULL)
 184                         return 0;
 185
 186                 /* call lvbo free function of quota master */
 187                 return qmt_hdls.qmth_lvbo_free(mdt->mdt_qmt_dev, res);
 188         }
 189
 190         return 0;
 191 }
 192
 193 struct ldlm_valblock_ops mdt_lvbo = {
 194         lvbo_init:      mdt_lvbo_init,
 195         lvbo_update:    mdt_lvbo_update,
 196         lvbo_size:      mdt_lvbo_size,
 197         lvbo_fill:      mdt_lvbo_fill,
 198         lvbo_free:      mdt_lvbo_free
 199 };