lustre/mdt/mdt_lib.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  lustre/mdt/mdt_lib.c
   5  *  Lustre Metadata Target (mdt) request unpacking helper.
   6  *
   7  *  Copyright (c) 2006 Cluster File Systems, Inc.
   8  *   Author: Peter Braam <braam@clusterfs.com>
   9  *   Author: Andreas Dilger <adilger@clusterfs.com>
  10  *   Author: Phil Schwan <phil@clusterfs.com>
  11  *   Author: Mike Shaver <shaver@clusterfs.com>
  12  *   Author: Nikita Danilov <nikita@clusterfs.com>
  13  *   Author: Huang Hua <huanghua@clusterfs.com>
  14  *
  15  *
  16  *   This file is part of the Lustre file system, http://www.lustre.org
  17  *   Lustre is a trademark of Cluster File Systems, Inc.
  18  *
  19  *   You may have signed or agreed to another license before downloading
  20  *   this software.  If so, you are bound by the terms and conditions
  21  *   of that agreement, and the following does not apply to you.  See the
  22  *   LICENSE file included with this distribution for more information.
  23  *
  24  *   If you did not agree to a different license, then this copy of Lustre
  25  *   is open source software; you can redistribute it and/or modify it
  26  *   under the terms of version 2 of the GNU General Public License as
  27  *   published by the Free Software Foundation.
  28  *
  29  *   In either case, Lustre is distributed in the hope that it will be
  30  *   useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  31  *   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  32  *   license text for more details.
  33  */
  34
  35
  36 #ifndef EXPORT_SYMTAB
  37 # define EXPORT_SYMTAB
  38 #endif
  39 #define DEBUG_SUBSYSTEM S_MDS
  40
  41 #include "mdt_internal.h"
  42
  43
  44 /* copied from lov/lov_ea.c, just for debugging, will be removed later */
  45 void mdt_dump_lmm(int level, struct lov_mds_md *lmm)
  46 {
  47         struct lov_ost_data_v1 *lod;
  48         int i;
  49         __s16 stripe_count =
  50                 le16_to_cpu(((struct lov_user_md*)lmm)->lmm_stripe_count);
  51
  52         CDEBUG(level, "objid "LPX64", magic 0x%08X, pattern %#X\n",
  53                le64_to_cpu(lmm->lmm_object_id), le32_to_cpu(lmm->lmm_magic),
  54                le32_to_cpu(lmm->lmm_pattern));
  55         CDEBUG(level,"stripe_size=0x%x, stripe_count=0x%x\n",
  56                le32_to_cpu(lmm->lmm_stripe_size),
  57                le32_to_cpu(lmm->lmm_stripe_count));
  58         LASSERT(stripe_count < (__s16)LOV_MAX_STRIPE_COUNT);
  59         for (i = 0, lod = lmm->lmm_objects; i < stripe_count; i++, lod++) {
  60                 CDEBUG(level, "stripe %u idx %u subobj "LPX64"/"LPX64"\n",
  61                        i, le32_to_cpu(lod->l_ost_idx),
  62                        le64_to_cpu(lod->l_object_gr),
  63                        le64_to_cpu(lod->l_object_id));
  64         }
  65 }
  66
  67 void mdt_shrink_reply(struct mdt_thread_info *info, int offset)
  68 {
  69         struct ptlrpc_request *req = mdt_info_req(info);
  70         struct mdt_body *body;
  71         int acl_size = 0;
  72         int md_size = 0;
  73
  74         body = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY);
  75         LASSERT(body != NULL);
  76
  77         md_size = body->eadatasize;
  78         acl_size = body->aclsize;
  79
  80         CDEBUG(D_INFO, "Shrink to md_size %d cookie_size %d \n",
  81                        md_size, acl_size);
  82
  83         lustre_shrink_reply(req, offset, md_size, 1);
  84         lustre_shrink_reply(req, md_size ? offset + 1: offset, acl_size, 0);
  85 }
  86
  87
  88 /* if object is dying, pack the lov/llog data,
  89  * parameter info->mti_attr should be valid at this point! */
  90 int mdt_handle_last_unlink(struct mdt_thread_info *info, struct mdt_object *mo,
  91                            const struct md_attr *ma)
  92 {
  93         struct mdt_body       *repbody;
  94         const struct lu_attr *la = &ma->ma_attr;
  95         ENTRY;
  96
  97         repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY);
  98         LASSERT(repbody != NULL);
  99
 100         if (ma->ma_valid & MA_INODE)
 101                 mdt_pack_attr2body(repbody, la, mdt_object_fid(mo));
 102
 103         if (ma->ma_valid & MA_LOV) {
 104                 __u32 mode;
 105
 106                 mode = lu_object_attr(&mo->mot_obj.mo_lu);
 107                 LASSERT(ma->ma_lmm_size);
 108                 mdt_dump_lmm(D_INFO, ma->ma_lmm);
 109                 repbody->eadatasize = ma->ma_lmm_size;
 110                 if (S_ISREG(mode))
 111                         repbody->valid |= OBD_MD_FLEASIZE;
 112                 else if (S_ISDIR(mode))
 113                         repbody->valid |= OBD_MD_FLDIREA;
 114                 else
 115                         LBUG();
 116         }
 117
 118         if (ma->ma_cookie_size && (ma->ma_valid & MA_COOKIE)) {
 119                 repbody->aclsize = ma->ma_cookie_size;
 120                 repbody->valid |= OBD_MD_FLCOOKIE;
 121         }
 122
 123         RETURN(0);
 124 }
 125
 126 static __u64 mdt_attr_valid_xlate(__u64 in, struct mdt_reint_record *rr,
 127                                   struct md_attr *ma)
 128 {
 129         __u64 out;
 130
 131         out = 0;
 132         if (in & ATTR_MODE)
 133                 out |= LA_MODE;
 134         if (in & ATTR_UID)
 135                 out |= LA_UID;
 136         if (in & ATTR_GID)
 137                 out |= LA_GID;
 138         if (in & ATTR_SIZE)
 139                 out |= LA_SIZE;
 140
 141         if (in & ATTR_FROM_OPEN)
 142                 rr->rr_flags |= MRF_SETATTR_LOCKED;
 143
 144         if (in & ATTR_ATIME_SET)
 145                 out |= LA_ATIME;
 146
 147         if (in & ATTR_CTIME_SET)
 148                 out |= LA_CTIME;
 149
 150         if (in & ATTR_MTIME_SET)
 151                 out |= LA_MTIME;
 152
 153         if (in & ATTR_ATTR_FLAG)
 154                 out |= LA_FLAGS;
 155
 156         /*XXX need ATTR_RAW?*/
 157         in &= ~(ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_SIZE|
 158                 ATTR_ATIME|ATTR_MTIME|ATTR_CTIME|ATTR_FROM_OPEN|
 159                 ATTR_ATIME_SET|ATTR_CTIME_SET|ATTR_MTIME_SET|
 160                 ATTR_ATTR_FLAG|ATTR_RAW);
 161         if (in != 0)
 162                 CERROR("Unknown attr bits: %#llx\n", in);
 163         return out;
 164 }
 165 /* unpacking */
 166 static int mdt_setattr_unpack(struct mdt_thread_info *info)
 167 {
 168         struct mdt_rec_setattr  *rec;
 169         struct md_attr          *ma = &info->mti_attr;
 170         struct lu_attr          *la = &ma->ma_attr;
 171         struct mdt_reint_record *rr = &info->mti_rr;
 172         struct req_capsule      *pill = &info->mti_pill;
 173         ENTRY;
 174
 175         rec = req_capsule_client_get(pill, &RMF_REC_SETATTR);
 176
 177         if (rec == NULL)
 178                 RETURN(-EFAULT);
 179
 180         rr->rr_fid1 = &rec->sa_fid;
 181         la->la_valid = mdt_attr_valid_xlate(rec->sa_valid, rr, ma);
 182         la->la_mode  = rec->sa_mode;
 183         la->la_flags = rec->sa_attr_flags;
 184         la->la_uid   = rec->sa_uid;
 185         la->la_gid   = rec->sa_gid;
 186         la->la_size  = rec->sa_size;
 187         la->la_ctime = rec->sa_ctime;
 188         la->la_atime = rec->sa_atime;
 189         la->la_mtime = rec->sa_mtime;
 190         ma->ma_valid = MA_INODE;
 191
 192         if (req_capsule_field_present(pill, &RMF_EADATA, RCL_CLIENT)) {
 193                 ma->ma_lmm = req_capsule_client_get(pill, &RMF_EADATA);
 194                 ma->ma_lmm_size = req_capsule_get_size(pill, &RMF_EADATA,
 195                                                        RCL_CLIENT);
 196                 ma->ma_valid |= MA_LOV;
 197         }
 198         if (req_capsule_field_present(pill, &RMF_LOGCOOKIES, RCL_CLIENT)) {
 199                 ma->ma_cookie = req_capsule_client_get(pill,
 200                                                        &RMF_LOGCOOKIES);
 201                 ma->ma_cookie_size = req_capsule_get_size(pill,
 202                                                           &RMF_LOGCOOKIES,
 203                                                           RCL_CLIENT);
 204                 ma->ma_valid |= MA_COOKIE;
 205         }
 206
 207         RETURN(0);
 208 }
 209
 210 static int mdt_create_unpack(struct mdt_thread_info *info)
 211 {
 212         struct mdt_rec_create   *rec;
 213         struct lu_attr          *attr = &info->mti_attr.ma_attr;
 214         struct mdt_reint_record *rr = &info->mti_rr;
 215         struct req_capsule      *pill = &info->mti_pill;
 216         int                     result = 0;
 217         ENTRY;
 218
 219         rec = req_capsule_client_get(pill, &RMF_REC_CREATE);
 220         if (rec != NULL) {
 221                 rr->rr_fid1 = &rec->cr_fid1;
 222                 rr->rr_fid2 = &rec->cr_fid2;
 223                 attr->la_mode = rec->cr_mode;
 224                 attr->la_rdev  = rec->cr_rdev;
 225                 attr->la_uid   = rec->cr_fsuid;
 226                 attr->la_gid   = rec->cr_fsgid;
 227                 attr->la_ctime = rec->cr_time;
 228                 attr->la_mtime = rec->cr_time;
 229                 attr->la_atime = rec->cr_time;
 230                 attr->la_valid = LA_MODE | LA_RDEV | LA_UID | LA_GID |
 231                                  LA_CTIME | LA_MTIME | LA_ATIME;
 232                 info->mti_spec.sp_cr_flags = rec->cr_flags;
 233
 234                 rr->rr_name = req_capsule_client_get(pill, &RMF_NAME);
 235                 if (S_ISDIR(attr->la_mode)) {
 236                         /* pass parent fid for cross-ref cases */
 237                         info->mti_spec.u.sp_pfid = rr->rr_fid1;
 238                 } else if (S_ISLNK(attr->la_mode)) {
 239                         const char *tgt = NULL;
 240                         if (req_capsule_field_present(pill, &RMF_SYMTGT,
 241                                                       RCL_CLIENT)) {
 242                                 tgt = req_capsule_client_get(pill,
 243                                                              &RMF_SYMTGT);
 244                                 info->mti_spec.u.sp_symname = tgt;
 245                         }
 246                         if (tgt == NULL)
 247                                 result = -EFAULT;
 248                 }
 249         } else
 250                 result = -EFAULT;
 251         RETURN(result);
 252 }
 253
 254 static int mdt_link_unpack(struct mdt_thread_info *info)
 255 {
 256         struct mdt_rec_link     *rec;
 257         struct lu_attr          *attr = &info->mti_attr.ma_attr;
 258         struct mdt_reint_record *rr = &info->mti_rr;
 259         struct req_capsule      *pill = &info->mti_pill;
 260         int                      result = 0;
 261         ENTRY;
 262
 263         rec = req_capsule_client_get(pill, &RMF_REC_LINK);
 264         if (rec != NULL) {
 265                 attr->la_uid = rec->lk_fsuid;
 266                 attr->la_gid = rec->lk_fsgid;
 267                 rr->rr_fid1 = &rec->lk_fid1;
 268                 rr->rr_fid2 = &rec->lk_fid2;
 269                 attr->la_ctime = rec->lk_time;
 270                 attr->la_mtime = rec->lk_time;
 271                 attr->la_valid = LA_UID | LA_GID | LA_CTIME | LA_MTIME;
 272                 rr->rr_name = req_capsule_client_get(pill, &RMF_NAME);
 273                 if (rr->rr_name == NULL)
 274                         result = -EFAULT;
 275         } else
 276                 result = -EFAULT;
 277         RETURN(result);
 278 }
 279
 280 static int mdt_unlink_unpack(struct mdt_thread_info *info)
 281 {
 282         struct mdt_rec_unlink   *rec;
 283         struct lu_attr          *attr = &info->mti_attr.ma_attr;
 284         struct mdt_reint_record *rr = &info->mti_rr;
 285         struct req_capsule      *pill = &info->mti_pill;
 286         int                      result = 0;
 287         ENTRY;
 288
 289         rec = req_capsule_client_get(pill, &RMF_REC_UNLINK);
 290         if (rec != NULL) {
 291                 attr->la_uid = rec->ul_fsuid;
 292                 attr->la_gid = rec->ul_fsgid;
 293                 rr->rr_fid1 = &rec->ul_fid1;
 294                 rr->rr_fid2 = &rec->ul_fid2;
 295                 attr->la_ctime = rec->ul_time;
 296                 attr->la_mtime = rec->ul_time;
 297                 attr->la_mode  = rec->ul_mode;
 298
 299                 attr->la_valid = LA_UID   | LA_GID  | LA_CTIME |
 300                                  LA_MTIME | LA_MODE;
 301                 rr->rr_name = req_capsule_client_get(pill, &RMF_NAME);
 302                 if (rr->rr_name == NULL)
 303                         result = -EFAULT;
 304         } else
 305                 result = -EFAULT;
 306         RETURN(result);
 307 }
 308
 309 static int mdt_rename_unpack(struct mdt_thread_info *info)
 310 {
 311         struct mdt_rec_rename   *rec;
 312         struct lu_attr          *attr = &info->mti_attr.ma_attr;
 313         struct mdt_reint_record *rr = &info->mti_rr;
 314         struct req_capsule      *pill = &info->mti_pill;
 315         int                      result = 0;
 316         ENTRY;
 317
 318         rec = req_capsule_client_get(pill, &RMF_REC_RENAME);
 319         if (rec != NULL) {
 320                 attr->la_uid = rec->rn_fsuid;
 321                 attr->la_gid = rec->rn_fsgid;
 322                 rr->rr_fid1 = &rec->rn_fid1;
 323                 rr->rr_fid2 = &rec->rn_fid2;
 324                 attr->la_ctime = rec->rn_time;
 325                 attr->la_mtime = rec->rn_time;
 326                 attr->la_valid = LA_UID | LA_GID | LA_CTIME | LA_MTIME;
 327                 rr->rr_name = req_capsule_client_get(pill, &RMF_NAME);
 328                 rr->rr_tgt = req_capsule_client_get(pill, &RMF_SYMTGT);
 329                 if (rr->rr_name == NULL || rr->rr_tgt == NULL)
 330                         result = -EFAULT;
 331         } else
 332                 result = -EFAULT;
 333         RETURN(result);
 334 }
 335
 336 static int mdt_open_unpack(struct mdt_thread_info *info)
 337 {
 338         struct mdt_rec_create   *rec;
 339         struct lu_attr          *attr = &info->mti_attr.ma_attr;
 340         struct req_capsule      *pill = &info->mti_pill;
 341         struct mdt_reint_record *rr   = &info->mti_rr;
 342         int                     result;
 343         ENTRY;
 344
 345         rec = req_capsule_client_get(pill, &RMF_REC_CREATE);
 346         if (rec != NULL) {
 347                 rr->rr_fid1   = &rec->cr_fid1;
 348                 rr->rr_fid2   = &rec->cr_fid2;
 349                 attr->la_mode = rec->cr_mode;
 350                 attr->la_rdev  = rec->cr_rdev;
 351                 attr->la_uid   = rec->cr_fsuid;
 352                 attr->la_gid   = rec->cr_fsgid;
 353                 attr->la_ctime = rec->cr_time;
 354                 attr->la_mtime = rec->cr_time;
 355                 attr->la_atime = rec->cr_time;
 356                 attr->la_valid = LA_MODE  | LA_RDEV  | LA_UID   | LA_GID |
 357                                  LA_CTIME | LA_MTIME | LA_ATIME;
 358                 info->mti_spec.sp_cr_flags = rec->cr_flags;
 359                 rr->rr_name = req_capsule_client_get(pill, &RMF_NAME);
 360                 if (rr->rr_name == NULL)
 361                         result = -EFAULT;
 362                 else
 363                         result = 0;
 364         } else
 365                 result = -EFAULT;
 366
 367         if (req_capsule_field_present(pill, &RMF_EADATA, RCL_CLIENT)) {
 368                 struct md_create_spec *sp = &info->mti_spec;
 369                 sp->u.sp_ea.eadata = req_capsule_client_get(pill,
 370                                                             &RMF_EADATA);
 371                 sp->u.sp_ea.eadatalen = req_capsule_get_size(pill,
 372                                                              &RMF_EADATA,
 373                                                              RCL_CLIENT);
 374         }
 375
 376         RETURN(result);
 377 }
 378
 379 typedef int (*reint_unpacker)(struct mdt_thread_info *info);
 380
 381 static reint_unpacker mdt_reint_unpackers[REINT_MAX] = {
 382         [REINT_SETATTR]  = mdt_setattr_unpack,
 383         [REINT_CREATE]   = mdt_create_unpack,
 384         [REINT_LINK]     = mdt_link_unpack,
 385         [REINT_UNLINK]   = mdt_unlink_unpack,
 386         [REINT_RENAME]   = mdt_rename_unpack,
 387         [REINT_OPEN]     = mdt_open_unpack
 388 };
 389
 390 int mdt_reint_unpack(struct mdt_thread_info *info, __u32 op)
 391 {
 392         int rc;
 393
 394         ENTRY;
 395
 396         if (op < REINT_MAX && mdt_reint_unpackers[op] != NULL) {
 397                 info->mti_rr.rr_opcode = op;
 398                 rc = mdt_reint_unpackers[op](info);
 399         } else {
 400                 CERROR("Unexpected opcode %d\n", op);
 401                 rc = -EFAULT;
 402         }
 403         RETURN(rc);
 404 }