drivers/staging/lustre/lustre/mdc/mdc_lib.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, 2015, Intel Corporation.
  27  */
  28 /*
  29  * This file is part of Lustre, http://www.lustre.org/
  30  * Lustre is a trademark of Sun Microsystems, Inc.
  31  */
  32
  33 #define DEBUG_SUBSYSTEM S_MDC
  34 #include <lustre_net.h>
  35 #include <uapi/linux/lustre/lustre_idl.h>
  36 #include "mdc_internal.h"
  37
  38 static void set_mrc_cr_flags(struct mdt_rec_create *mrc, u64 flags)
  39 {
  40         mrc->cr_flags_l = (u32)(flags & 0xFFFFFFFFUll);
  41         mrc->cr_flags_h = (u32)(flags >> 32);
  42 }
  43
  44 static void __mdc_pack_body(struct mdt_body *b, __u32 suppgid)
  45 {
  46         b->mbo_suppgid = suppgid;
  47         b->mbo_uid = from_kuid(&init_user_ns, current_uid());
  48         b->mbo_gid = from_kgid(&init_user_ns, current_gid());
  49         b->mbo_fsuid = from_kuid(&init_user_ns, current_fsuid());
  50         b->mbo_fsgid = from_kgid(&init_user_ns, current_fsgid());
  51         b->mbo_capability = cfs_curproc_cap_pack();
  52 }
  53
  54 void mdc_swap_layouts_pack(struct ptlrpc_request *req,
  55                            struct md_op_data *op_data)
  56 {
  57         struct mdt_body *b = req_capsule_client_get(&req->rq_pill,
  58                                                     &RMF_MDT_BODY);
  59
  60         __mdc_pack_body(b, op_data->op_suppgids[0]);
  61         b->mbo_fid1 = op_data->op_fid1;
  62         b->mbo_fid2 = op_data->op_fid2;
  63         b->mbo_valid |= OBD_MD_FLID;
  64 }
  65
  66 void mdc_pack_body(struct ptlrpc_request *req, const struct lu_fid *fid,
  67                    __u64 valid, size_t ea_size, __u32 suppgid, u32 flags)
  68 {
  69         struct mdt_body *b = req_capsule_client_get(&req->rq_pill,
  70                                                     &RMF_MDT_BODY);
  71         b->mbo_valid = valid;
  72         b->mbo_eadatasize = ea_size;
  73         b->mbo_flags = flags;
  74         __mdc_pack_body(b, suppgid);
  75         if (fid) {
  76                 b->mbo_fid1 = *fid;
  77                 b->mbo_valid |= OBD_MD_FLID;
  78         }
  79 }
  80
  81 /**
  82  * Pack a name (path component) into a request
  83  *
  84  * \param[in] req       request
  85  * \param[in] field     request field (usually RMF_NAME)
  86  * \param[in] name      path component
  87  * \param[in] name_len  length of path component
  88  *
  89  * \a field must be present in \a req and of size \a name_len + 1.
  90  *
  91  * \a name must be '\0' terminated of length \a name_len and represent
  92  * a single path component (not contain '/').
  93  */
  94 static void mdc_pack_name(struct ptlrpc_request *req,
  95                           const struct req_msg_field *field,
  96                           const char *name, size_t name_len)
  97 {
  98         size_t buf_size;
  99         size_t cpy_len;
 100         char *buf;
 101
 102         buf = req_capsule_client_get(&req->rq_pill, field);
 103         buf_size = req_capsule_get_size(&req->rq_pill, field, RCL_CLIENT);
 104
 105         LASSERT(name && name_len && buf && buf_size == name_len + 1);
 106
 107         cpy_len = strlcpy(buf, name, buf_size);
 108
 109         LASSERT(cpy_len == name_len && lu_name_is_valid_2(buf, cpy_len));
 110 }
 111
 112 void mdc_readdir_pack(struct ptlrpc_request *req, __u64 pgoff, size_t size,
 113                       const struct lu_fid *fid)
 114 {
 115         struct mdt_body *b = req_capsule_client_get(&req->rq_pill,
 116                                                     &RMF_MDT_BODY);
 117         b->mbo_fid1 = *fid;
 118         b->mbo_valid |= OBD_MD_FLID;
 119         b->mbo_size = pgoff;                   /* !! */
 120         b->mbo_nlink = size;                    /* !! */
 121         __mdc_pack_body(b, -1);
 122         b->mbo_mode = LUDA_FID | LUDA_TYPE;
 123 }
 124
 125 /* packing of MDS records */
 126 void mdc_create_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
 127                      const void *data, size_t datalen, umode_t mode,
 128                      uid_t uid, gid_t gid, cfs_cap_t cap_effective, __u64 rdev)
 129 {
 130         struct mdt_rec_create   *rec;
 131         char                    *tmp;
 132         __u64                    flags;
 133
 134         BUILD_BUG_ON(sizeof(struct mdt_rec_reint) != sizeof(struct mdt_rec_create));
 135         rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
 136
 137         rec->cr_opcode   = REINT_CREATE;
 138         rec->cr_fsuid    = uid;
 139         rec->cr_fsgid    = gid;
 140         rec->cr_cap      = cap_effective;
 141         rec->cr_fid1     = op_data->op_fid1;
 142         rec->cr_fid2     = op_data->op_fid2;
 143         rec->cr_mode     = mode;
 144         rec->cr_rdev     = rdev;
 145         rec->cr_time     = op_data->op_mod_time;
 146         rec->cr_suppgid1 = op_data->op_suppgids[0];
 147         rec->cr_suppgid2 = op_data->op_suppgids[1];
 148         flags = 0;
 149         if (op_data->op_bias & MDS_CREATE_VOLATILE)
 150                 flags |= MDS_OPEN_VOLATILE;
 151         set_mrc_cr_flags(rec, flags);
 152         rec->cr_bias     = op_data->op_bias;
 153         rec->cr_umask    = current_umask();
 154
 155         mdc_pack_name(req, &RMF_NAME, op_data->op_name, op_data->op_namelen);
 156         if (data) {
 157                 tmp = req_capsule_client_get(&req->rq_pill, &RMF_EADATA);
 158                 memcpy(tmp, data, datalen);
 159         }
 160 }
 161
 162 static inline __u64 mds_pack_open_flags(__u64 flags)
 163 {
 164         __u64 cr_flags = (flags & (FMODE_READ | FMODE_WRITE |
 165                                    MDS_OPEN_FL_INTERNAL));
 166         if (flags & O_CREAT)
 167                 cr_flags |= MDS_OPEN_CREAT;
 168         if (flags & O_EXCL)
 169                 cr_flags |= MDS_OPEN_EXCL;
 170         if (flags & O_TRUNC)
 171                 cr_flags |= MDS_OPEN_TRUNC;
 172         if (flags & O_APPEND)
 173                 cr_flags |= MDS_OPEN_APPEND;
 174         if (flags & O_SYNC)
 175                 cr_flags |= MDS_OPEN_SYNC;
 176         if (flags & O_DIRECTORY)
 177                 cr_flags |= MDS_OPEN_DIRECTORY;
 178         if (flags & __FMODE_EXEC)
 179                 cr_flags |= MDS_FMODE_EXEC;
 180         if (cl_is_lov_delay_create(flags))
 181                 cr_flags |= MDS_OPEN_DELAY_CREATE;
 182
 183         if (flags & O_NONBLOCK)
 184                 cr_flags |= MDS_OPEN_NORESTORE;
 185
 186         return cr_flags;
 187 }
 188
 189 /* packing of MDS records */
 190 void mdc_open_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
 191                    umode_t mode, __u64 rdev, __u64 flags, const void *lmm,
 192                    size_t lmmlen)
 193 {
 194         struct mdt_rec_create *rec;
 195         char *tmp;
 196         __u64 cr_flags;
 197
 198         BUILD_BUG_ON(sizeof(struct mdt_rec_reint) != sizeof(struct mdt_rec_create));
 199         rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
 200
 201         /* XXX do something about time, uid, gid */
 202         rec->cr_opcode   = REINT_OPEN;
 203         rec->cr_fsuid    = from_kuid(&init_user_ns, current_fsuid());
 204         rec->cr_fsgid    = from_kgid(&init_user_ns, current_fsgid());
 205         rec->cr_cap      = cfs_curproc_cap_pack();
 206         rec->cr_fid1 = op_data->op_fid1;
 207         rec->cr_fid2 = op_data->op_fid2;
 208
 209         rec->cr_mode     = mode;
 210         cr_flags = mds_pack_open_flags(flags);
 211         rec->cr_rdev     = rdev;
 212         rec->cr_time     = op_data->op_mod_time;
 213         rec->cr_suppgid1 = op_data->op_suppgids[0];
 214         rec->cr_suppgid2 = op_data->op_suppgids[1];
 215         rec->cr_bias     = op_data->op_bias;
 216         rec->cr_umask    = current_umask();
 217         rec->cr_old_handle = op_data->op_handle;
 218
 219         if (op_data->op_name) {
 220                 mdc_pack_name(req, &RMF_NAME, op_data->op_name,
 221                               op_data->op_namelen);
 222
 223                 if (op_data->op_bias & MDS_CREATE_VOLATILE)
 224                         cr_flags |= MDS_OPEN_VOLATILE;
 225         }
 226
 227         if (lmm) {
 228                 cr_flags |= MDS_OPEN_HAS_EA;
 229                 tmp = req_capsule_client_get(&req->rq_pill, &RMF_EADATA);
 230                 memcpy(tmp, lmm, lmmlen);
 231         }
 232         set_mrc_cr_flags(rec, cr_flags);
 233 }
 234
 235 static inline __u64 attr_pack(unsigned int ia_valid)
 236 {
 237         __u64 sa_valid = 0;
 238
 239         if (ia_valid & ATTR_MODE)
 240                 sa_valid |= MDS_ATTR_MODE;
 241         if (ia_valid & ATTR_UID)
 242                 sa_valid |= MDS_ATTR_UID;
 243         if (ia_valid & ATTR_GID)
 244                 sa_valid |= MDS_ATTR_GID;
 245         if (ia_valid & ATTR_SIZE)
 246                 sa_valid |= MDS_ATTR_SIZE;
 247         if (ia_valid & ATTR_ATIME)
 248                 sa_valid |= MDS_ATTR_ATIME;
 249         if (ia_valid & ATTR_MTIME)
 250                 sa_valid |= MDS_ATTR_MTIME;
 251         if (ia_valid & ATTR_CTIME)
 252                 sa_valid |= MDS_ATTR_CTIME;
 253         if (ia_valid & ATTR_ATIME_SET)
 254                 sa_valid |= MDS_ATTR_ATIME_SET;
 255         if (ia_valid & ATTR_MTIME_SET)
 256                 sa_valid |= MDS_ATTR_MTIME_SET;
 257         if (ia_valid & ATTR_FORCE)
 258                 sa_valid |= MDS_ATTR_FORCE;
 259         if (ia_valid & ATTR_ATTR_FLAG)
 260                 sa_valid |= MDS_ATTR_ATTR_FLAG;
 261         if (ia_valid & ATTR_KILL_SUID)
 262                 sa_valid |=  MDS_ATTR_KILL_SUID;
 263         if (ia_valid & ATTR_KILL_SGID)
 264                 sa_valid |= MDS_ATTR_KILL_SGID;
 265         if (ia_valid & ATTR_CTIME_SET)
 266                 sa_valid |= MDS_ATTR_CTIME_SET;
 267         if (ia_valid & ATTR_OPEN)
 268                 sa_valid |= MDS_ATTR_FROM_OPEN;
 269         if (ia_valid & ATTR_BLOCKS)
 270                 sa_valid |= MDS_ATTR_BLOCKS;
 271         if (ia_valid & MDS_OPEN_OWNEROVERRIDE)
 272                 /* NFSD hack (see bug 5781) */
 273                 sa_valid |= MDS_OPEN_OWNEROVERRIDE;
 274         return sa_valid;
 275 }
 276
 277 static void mdc_setattr_pack_rec(struct mdt_rec_setattr *rec,
 278                                  struct md_op_data *op_data)
 279 {
 280         rec->sa_opcode  = REINT_SETATTR;
 281         rec->sa_fsuid   = from_kuid(&init_user_ns, current_fsuid());
 282         rec->sa_fsgid   = from_kgid(&init_user_ns, current_fsgid());
 283         rec->sa_cap     = cfs_curproc_cap_pack();
 284         rec->sa_suppgid = -1;
 285
 286         rec->sa_fid    = op_data->op_fid1;
 287         rec->sa_valid  = attr_pack(op_data->op_attr.ia_valid);
 288         rec->sa_mode   = op_data->op_attr.ia_mode;
 289         rec->sa_uid    = from_kuid(&init_user_ns, op_data->op_attr.ia_uid);
 290         rec->sa_gid    = from_kgid(&init_user_ns, op_data->op_attr.ia_gid);
 291         rec->sa_size   = op_data->op_attr.ia_size;
 292         rec->sa_blocks = op_data->op_attr_blocks;
 293         rec->sa_atime  = LTIME_S(op_data->op_attr.ia_atime);
 294         rec->sa_mtime  = LTIME_S(op_data->op_attr.ia_mtime);
 295         rec->sa_ctime  = LTIME_S(op_data->op_attr.ia_ctime);
 296         rec->sa_attr_flags = op_data->op_attr_flags;
 297         if ((op_data->op_attr.ia_valid & ATTR_GID) &&
 298             in_group_p(op_data->op_attr.ia_gid))
 299                 rec->sa_suppgid =
 300                         from_kgid(&init_user_ns, op_data->op_attr.ia_gid);
 301         else
 302                 rec->sa_suppgid = op_data->op_suppgids[0];
 303
 304         rec->sa_bias = op_data->op_bias;
 305 }
 306
 307 static void mdc_ioepoch_pack(struct mdt_ioepoch *epoch,
 308                              struct md_op_data *op_data)
 309 {
 310         epoch->mio_handle = op_data->op_handle;
 311         epoch->mio_unused1 = 0;
 312         epoch->mio_unused2 = 0;
 313         epoch->mio_padding = 0;
 314 }
 315
 316 void mdc_setattr_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
 317                       void *ea, size_t ealen)
 318 {
 319         struct mdt_rec_setattr *rec;
 320         struct lov_user_md *lum = NULL;
 321
 322         BUILD_BUG_ON(sizeof(struct mdt_rec_reint) !=
 323                                         sizeof(struct mdt_rec_setattr));
 324         rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
 325         mdc_setattr_pack_rec(rec, op_data);
 326
 327         if (ealen == 0)
 328                 return;
 329
 330         lum = req_capsule_client_get(&req->rq_pill, &RMF_EADATA);
 331         if (!ea) { /* Remove LOV EA */
 332                 lum->lmm_magic = cpu_to_le32(LOV_USER_MAGIC_V1);
 333                 lum->lmm_stripe_size = 0;
 334                 lum->lmm_stripe_count = 0;
 335                 lum->lmm_stripe_offset = (typeof(lum->lmm_stripe_offset))(-1);
 336         } else {
 337                 memcpy(lum, ea, ealen);
 338         }
 339 }
 340
 341 void mdc_unlink_pack(struct ptlrpc_request *req, struct md_op_data *op_data)
 342 {
 343         struct mdt_rec_unlink *rec;
 344
 345         BUILD_BUG_ON(sizeof(struct mdt_rec_reint) != sizeof(struct mdt_rec_unlink));
 346         rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
 347
 348         rec->ul_opcode   = op_data->op_cli_flags & CLI_RM_ENTRY ?
 349                                         REINT_RMENTRY : REINT_UNLINK;
 350         rec->ul_fsuid    = op_data->op_fsuid;
 351         rec->ul_fsgid    = op_data->op_fsgid;
 352         rec->ul_cap      = op_data->op_cap;
 353         rec->ul_mode     = op_data->op_mode;
 354         rec->ul_suppgid1 = op_data->op_suppgids[0];
 355         rec->ul_suppgid2 = -1;
 356         rec->ul_fid1     = op_data->op_fid1;
 357         rec->ul_fid2     = op_data->op_fid2;
 358         rec->ul_time     = op_data->op_mod_time;
 359         rec->ul_bias     = op_data->op_bias;
 360
 361         mdc_pack_name(req, &RMF_NAME, op_data->op_name, op_data->op_namelen);
 362 }
 363
 364 void mdc_link_pack(struct ptlrpc_request *req, struct md_op_data *op_data)
 365 {
 366         struct mdt_rec_link *rec;
 367
 368         BUILD_BUG_ON(sizeof(struct mdt_rec_reint) != sizeof(struct mdt_rec_link));
 369         rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
 370
 371         rec->lk_opcode   = REINT_LINK;
 372         rec->lk_fsuid    = op_data->op_fsuid; /* current->fsuid; */
 373         rec->lk_fsgid    = op_data->op_fsgid; /* current->fsgid; */
 374         rec->lk_cap      = op_data->op_cap;   /* current->cap_effective; */
 375         rec->lk_suppgid1 = op_data->op_suppgids[0];
 376         rec->lk_suppgid2 = op_data->op_suppgids[1];
 377         rec->lk_fid1     = op_data->op_fid1;
 378         rec->lk_fid2     = op_data->op_fid2;
 379         rec->lk_time     = op_data->op_mod_time;
 380         rec->lk_bias     = op_data->op_bias;
 381
 382         mdc_pack_name(req, &RMF_NAME, op_data->op_name, op_data->op_namelen);
 383 }
 384
 385 static void mdc_intent_close_pack(struct ptlrpc_request *req,
 386                                   struct md_op_data *op_data)
 387 {
 388         enum mds_op_bias bias = op_data->op_bias;
 389         struct close_data *data;
 390         struct ldlm_lock *lock;
 391
 392         if (!(bias & (MDS_HSM_RELEASE | MDS_CLOSE_LAYOUT_SWAP |
 393                       MDS_RENAME_MIGRATE)))
 394                 return;
 395
 396         data = req_capsule_client_get(&req->rq_pill, &RMF_CLOSE_DATA);
 397         LASSERT(data);
 398
 399         lock = ldlm_handle2lock(&op_data->op_lease_handle);
 400         if (lock) {
 401                 data->cd_handle = lock->l_remote_handle;
 402                 LDLM_LOCK_PUT(lock);
 403         }
 404         ldlm_cli_cancel(&op_data->op_lease_handle, LCF_LOCAL);
 405
 406         data->cd_data_version = op_data->op_data_version;
 407         data->cd_fid = op_data->op_fid2;
 408 }
 409
 410 void mdc_rename_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
 411                      const char *old, size_t oldlen,
 412                      const char *new, size_t newlen)
 413 {
 414         struct mdt_rec_rename *rec;
 415
 416         BUILD_BUG_ON(sizeof(struct mdt_rec_reint) != sizeof(struct mdt_rec_rename));
 417         rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
 418
 419         /* XXX do something about time, uid, gid */
 420         rec->rn_opcode   = op_data->op_cli_flags & CLI_MIGRATE ?
 421                                 REINT_MIGRATE : REINT_RENAME;
 422         rec->rn_opcode   = REINT_RENAME;
 423         rec->rn_fsuid    = op_data->op_fsuid;
 424         rec->rn_fsgid    = op_data->op_fsgid;
 425         rec->rn_cap      = op_data->op_cap;
 426         rec->rn_suppgid1 = op_data->op_suppgids[0];
 427         rec->rn_suppgid2 = op_data->op_suppgids[1];
 428         rec->rn_fid1     = op_data->op_fid1;
 429         rec->rn_fid2     = op_data->op_fid2;
 430         rec->rn_time     = op_data->op_mod_time;
 431         rec->rn_mode     = op_data->op_mode;
 432         rec->rn_bias     = op_data->op_bias;
 433
 434         mdc_pack_name(req, &RMF_NAME, old, oldlen);
 435
 436         if (new)
 437                 mdc_pack_name(req, &RMF_SYMTGT, new, newlen);
 438
 439         if (op_data->op_cli_flags & CLI_MIGRATE &&
 440             op_data->op_bias & MDS_RENAME_MIGRATE) {
 441                 struct mdt_ioepoch *epoch;
 442
 443                 mdc_intent_close_pack(req, op_data);
 444                 epoch = req_capsule_client_get(&req->rq_pill, &RMF_MDT_EPOCH);
 445                 mdc_ioepoch_pack(epoch, op_data);
 446         }
 447 }
 448
 449 void mdc_getattr_pack(struct ptlrpc_request *req, __u64 valid, u32 flags,
 450                       struct md_op_data *op_data, size_t ea_size)
 451 {
 452         struct mdt_body *b = req_capsule_client_get(&req->rq_pill,
 453                                                     &RMF_MDT_BODY);
 454
 455         b->mbo_valid = valid;
 456         if (op_data->op_bias & MDS_CHECK_SPLIT)
 457                 b->mbo_valid |= OBD_MD_FLCKSPLIT;
 458         if (op_data->op_bias & MDS_CROSS_REF)
 459                 b->mbo_valid |= OBD_MD_FLCROSSREF;
 460         b->mbo_eadatasize = ea_size;
 461         b->mbo_flags = flags;
 462         __mdc_pack_body(b, op_data->op_suppgids[0]);
 463
 464         b->mbo_fid1 = op_data->op_fid1;
 465         b->mbo_fid2 = op_data->op_fid2;
 466         b->mbo_valid |= OBD_MD_FLID;
 467
 468         if (op_data->op_name)
 469                 mdc_pack_name(req, &RMF_NAME, op_data->op_name,
 470                               op_data->op_namelen);
 471 }
 472
 473 void mdc_close_pack(struct ptlrpc_request *req, struct md_op_data *op_data)
 474 {
 475         struct mdt_ioepoch *epoch;
 476         struct mdt_rec_setattr *rec;
 477
 478         epoch = req_capsule_client_get(&req->rq_pill, &RMF_MDT_EPOCH);
 479         rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
 480
 481         mdc_setattr_pack_rec(rec, op_data);
 482         /*
 483          * The client will zero out local timestamps when losing the IBITS lock
 484          * so any new RPC timestamps will update the client inode's timestamps.
 485          * There was a defect on the server side which allowed the atime to be
 486          * overwritten by a zeroed-out atime packed into the close RPC.
 487          *
 488          * Proactively clear the MDS_ATTR_ATIME flag in the RPC in this case
 489          * to avoid zeroing the atime on old unpatched servers.  See LU-8041.
 490          */
 491         if (rec->sa_atime == 0)
 492                 rec->sa_valid &= ~MDS_ATTR_ATIME;
 493
 494         mdc_ioepoch_pack(epoch, op_data);
 495         mdc_intent_close_pack(req, op_data);
 496 }