4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
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.
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).
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
23 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Use is subject to license terms.
26 * Copyright (c) 2011, 2017, Intel Corporation.
29 * This file is part of Lustre, http://www.lustre.org/
32 #define DEBUG_SUBSYSTEM S_MDC
33 #include <linux/user_namespace.h>
34 #include <linux/uidgid.h>
36 #include <lustre_net.h>
37 #include <obd_class.h>
39 #include <cl_object.h>
40 #include "mdc_internal.h"
42 static void set_mrc_cr_flags(struct mdt_rec_create *mrc, __u64 flags)
44 mrc->cr_flags_l = (__u32)(flags & 0xFFFFFFFFUll);
45 mrc->cr_flags_h = (__u32)(flags >> 32);
48 static void __mdc_pack_body(struct mdt_body *b, __u32 suppgid)
52 b->mbo_suppgid = suppgid;
53 b->mbo_uid = from_kuid(&init_user_ns, current_uid());
54 b->mbo_gid = from_kgid(&init_user_ns, current_gid());
55 b->mbo_fsuid = from_kuid(&init_user_ns, current_fsuid());
56 b->mbo_fsgid = from_kgid(&init_user_ns, current_fsgid());
57 b->mbo_capability = ll_capability_u32(current_cap());
60 void mdc_swap_layouts_pack(struct req_capsule *pill,
61 struct md_op_data *op_data)
63 struct mdt_body *b = req_capsule_client_get(pill, &RMF_MDT_BODY);
65 __mdc_pack_body(b, op_data->op_suppgids[0]);
66 b->mbo_fid1 = op_data->op_fid1;
67 b->mbo_fid2 = op_data->op_fid2;
68 b->mbo_valid |= OBD_MD_FLID;
71 void mdc_pack_body(struct req_capsule *pill, const struct lu_fid *fid,
72 u64 valid, size_t ea_size, u32 suppgid, u32 flags)
74 struct mdt_body *b = req_capsule_client_get(pill, &RMF_MDT_BODY);
77 b->mbo_eadatasize = ea_size;
79 __mdc_pack_body(b, suppgid);
82 b->mbo_valid |= OBD_MD_FLID;
87 * Pack a name (path component) into a request
89 * \param[in] pill request pill
90 * \param[in] field request field (usually RMF_NAME)
91 * \param[in] name path component
92 * \param[in] name_len length of path component
94 * \a field must be present in \a req and of size \a name_len + 1.
96 * \a name must be '\0' terminated of length \a name_len and represent
97 * a single path component (not contain '/').
99 static void mdc_pack_name(struct req_capsule *pill,
100 const struct req_msg_field *field,
101 const char *name, size_t name_len)
107 buf = req_capsule_client_get(pill, field);
108 buf_size = req_capsule_get_size(pill, field, RCL_CLIENT);
110 LASSERT(buf != NULL && buf_size == name_len + 1);
113 buf[name_len] = '\0';
116 cpy_len = strlcpy(buf, name, buf_size);
118 LASSERT(lu_name_is_valid_2(buf, cpy_len));
119 if (cpy_len != name_len)
120 CDEBUG(D_DENTRY, "%s len %zd != %zd, concurrent rename?\n",
121 buf, name_len, cpy_len);
124 void mdc_file_secctx_pack(struct req_capsule *pill, const char *secctx_name,
125 const void *secctx, size_t secctx_size)
130 if (secctx_name == NULL)
133 buf = req_capsule_client_get(pill, &RMF_FILE_SECCTX_NAME);
134 buf_size = req_capsule_get_size(pill, &RMF_FILE_SECCTX_NAME,
137 LASSERT(buf_size == strlen(secctx_name) + 1);
138 memcpy(buf, secctx_name, buf_size);
140 buf = req_capsule_client_get(pill, &RMF_FILE_SECCTX);
141 buf_size = req_capsule_get_size(pill, &RMF_FILE_SECCTX,
144 LASSERT(buf_size == secctx_size);
145 memcpy(buf, secctx, buf_size);
148 void mdc_file_encctx_pack(struct req_capsule *pill,
149 const void *encctx, size_t encctx_size)
157 buf = req_capsule_client_get(pill, &RMF_FILE_ENCCTX);
158 buf_size = req_capsule_get_size(pill, &RMF_FILE_ENCCTX,
161 LASSERT(buf_size == encctx_size);
162 memcpy(buf, encctx, buf_size);
165 void mdc_file_sepol_pack(struct req_capsule *pill, struct sptlrpc_sepol *p)
170 if (!p || !p->ssp_sepol_size)
173 buf = req_capsule_client_get(pill, &RMF_SELINUX_POL);
174 buf_size = req_capsule_get_size(pill, &RMF_SELINUX_POL,
177 LASSERT(buf_size == p->ssp_sepol_size);
178 strlcpy(buf, p->ssp_sepol, p->ssp_sepol_size);
181 void mdc_readdir_pack(struct req_capsule *pill, __u64 pgoff, size_t size,
182 const struct lu_fid *fid)
184 struct mdt_body *b = req_capsule_client_get(pill, &RMF_MDT_BODY);
187 b->mbo_valid |= OBD_MD_FLID;
188 b->mbo_size = pgoff; /* !! */
189 b->mbo_nlink = size; /* !! */
190 __mdc_pack_body(b, -1);
191 b->mbo_mode = LUDA_FID | LUDA_TYPE;
194 /* packing of MDS records */
195 void mdc_create_pack(struct req_capsule *pill, struct md_op_data *op_data,
196 const void *data, size_t datalen, umode_t mode,
197 uid_t uid, gid_t gid, kernel_cap_t cap_effective, u64 rdev,
198 struct sptlrpc_sepol *sepol)
200 struct mdt_rec_create *rec;
204 BUILD_BUG_ON(sizeof(struct mdt_rec_reint) !=
205 sizeof(struct mdt_rec_create));
206 rec = req_capsule_client_get(pill, &RMF_REC_REINT);
208 rec->cr_opcode = REINT_CREATE;
211 rec->cr_cap = ll_capability_u32(cap_effective);
212 rec->cr_fid1 = op_data->op_fid1;
213 rec->cr_fid2 = op_data->op_fid2;
216 rec->cr_time = op_data->op_mod_time;
217 rec->cr_suppgid1 = op_data->op_suppgids[0];
218 rec->cr_suppgid2 = op_data->op_suppgids[1];
222 flags |= MDS_MKDIR_LMV;
223 if (op_data->op_bias & MDS_CREATE_VOLATILE)
224 flags |= MDS_OPEN_VOLATILE;
225 if (op_data->op_bias & MDS_SETSTRIPE_CREATE)
226 /* borrow MDS_OPEN_CREATE flag to indicate current setstripe
227 * create only, and don't restripe if object exists.
229 flags |= MDS_OPEN_CREAT;
230 if (op_data->op_bias & MDS_CREATE_DEFAULT_LMV) {
231 /* borrow MDS_OPEN_DEFAULT_LMV flag to indicate parent default
232 * LMV is packed in create request.
234 flags |= MDS_OPEN_DEFAULT_LMV;
237 set_mrc_cr_flags(rec, flags);
238 rec->cr_bias = op_data->op_bias;
239 rec->cr_umask = current_umask();
241 mdc_pack_name(pill, &RMF_NAME, op_data->op_name, op_data->op_namelen);
243 tmp = req_capsule_client_get(pill, &RMF_EADATA);
244 memcpy(tmp, data, datalen);
247 mdc_file_secctx_pack(pill, op_data->op_file_secctx_name,
248 op_data->op_file_secctx,
249 op_data->op_file_secctx_size);
251 mdc_file_encctx_pack(pill, op_data->op_file_encctx,
252 op_data->op_file_encctx_size);
254 /* pack SELinux policy info if any */
255 mdc_file_sepol_pack(pill, sepol);
258 static inline __u64 mds_pack_open_flags(__u64 flags)
260 __u64 cr_flags = (flags & MDS_OPEN_FL_INTERNAL);
262 if (flags & FMODE_READ)
263 cr_flags |= MDS_FMODE_READ;
264 if (flags & FMODE_WRITE)
265 cr_flags |= MDS_FMODE_WRITE;
267 cr_flags |= MDS_OPEN_CREAT;
269 cr_flags |= MDS_OPEN_EXCL;
271 cr_flags |= MDS_OPEN_TRUNC;
272 if (flags & O_APPEND)
273 cr_flags |= MDS_OPEN_APPEND;
275 cr_flags |= MDS_OPEN_SYNC;
276 if (flags & O_DIRECTORY)
277 cr_flags |= MDS_OPEN_DIRECTORY;
279 if (flags & FMODE_EXEC)
280 cr_flags |= MDS_FMODE_EXEC;
282 if (cl_is_lov_delay_create(flags))
283 cr_flags |= MDS_OPEN_DELAY_CREATE;
285 if (flags & O_NONBLOCK)
286 cr_flags |= MDS_OPEN_NORESTORE;
291 /* packing of MDS records */
292 void mdc_open_pack(struct req_capsule *pill, struct md_op_data *op_data,
293 umode_t mode, __u64 rdev, __u64 flags, const void *lmm,
294 size_t lmmlen, struct sptlrpc_sepol *sepol)
296 struct mdt_rec_create *rec;
300 BUILD_BUG_ON(sizeof(struct mdt_rec_reint) !=
301 sizeof(struct mdt_rec_create));
302 rec = req_capsule_client_get(pill, &RMF_REC_REINT);
304 /* XXX do something about time, uid, gid */
305 rec->cr_opcode = REINT_OPEN;
306 rec->cr_fsuid = from_kuid(&init_user_ns, current_fsuid());
307 rec->cr_fsgid = from_kgid(&init_user_ns, current_fsgid());
308 rec->cr_cap = ll_capability_u32(current_cap());
310 cr_flags = mds_pack_open_flags(flags);
312 rec->cr_umask = current_umask();
313 if (op_data != NULL) {
314 rec->cr_fid1 = op_data->op_fid1;
315 rec->cr_fid2 = op_data->op_fid2;
316 rec->cr_time = op_data->op_mod_time;
317 rec->cr_suppgid1 = op_data->op_suppgids[0];
318 rec->cr_suppgid2 = op_data->op_suppgids[1];
319 rec->cr_bias = op_data->op_bias;
320 rec->cr_open_handle_old = op_data->op_open_handle;
322 if (op_data->op_name) {
323 mdc_pack_name(pill, &RMF_NAME, op_data->op_name,
324 op_data->op_namelen);
326 if (op_data->op_bias & MDS_CREATE_VOLATILE)
327 cr_flags |= MDS_OPEN_VOLATILE;
330 mdc_file_secctx_pack(pill, op_data->op_file_secctx_name,
331 op_data->op_file_secctx,
332 op_data->op_file_secctx_size);
334 mdc_file_encctx_pack(pill, op_data->op_file_encctx,
335 op_data->op_file_encctx_size);
337 /* pack SELinux policy info if any */
338 mdc_file_sepol_pack(pill, sepol);
342 cr_flags |= MDS_OPEN_HAS_EA;
343 tmp = req_capsule_client_get(pill, &RMF_EADATA);
344 memcpy(tmp, lmm, lmmlen);
345 if (cr_flags & MDS_OPEN_PCC) {
346 LASSERT(op_data != NULL);
347 rec->cr_archive_id = op_data->op_archive_id;
350 cr_flags |= MDS_OPEN_DEFAULT_LMV;
351 set_mrc_cr_flags(rec, cr_flags);
354 static inline enum mds_attr_flags mdc_attr_pack(unsigned int ia_valid,
355 enum op_xvalid ia_xvalid)
357 enum mds_attr_flags sa_valid = 0;
359 if (ia_valid & ATTR_MODE)
360 sa_valid |= MDS_ATTR_MODE;
361 if (ia_valid & ATTR_UID)
362 sa_valid |= MDS_ATTR_UID;
363 if (ia_valid & ATTR_GID)
364 sa_valid |= MDS_ATTR_GID;
365 if (ia_valid & ATTR_SIZE)
366 sa_valid |= MDS_ATTR_SIZE;
367 if (ia_valid & ATTR_ATIME)
368 sa_valid |= MDS_ATTR_ATIME;
369 if (ia_valid & ATTR_MTIME)
370 sa_valid |= MDS_ATTR_MTIME;
371 if (ia_valid & ATTR_CTIME)
372 sa_valid |= MDS_ATTR_CTIME;
373 if (ia_valid & ATTR_ATIME_SET)
374 sa_valid |= MDS_ATTR_ATIME_SET;
375 if (ia_valid & ATTR_MTIME_SET)
376 sa_valid |= MDS_ATTR_MTIME_SET;
377 if (ia_valid & ATTR_FORCE)
378 sa_valid |= MDS_ATTR_FORCE;
379 if (ia_xvalid & OP_XVALID_FLAGS)
380 sa_valid |= MDS_ATTR_ATTR_FLAG;
381 if (ia_valid & ATTR_KILL_SUID)
382 sa_valid |= MDS_ATTR_KILL_SUID;
383 if (ia_valid & ATTR_KILL_SGID)
384 sa_valid |= MDS_ATTR_KILL_SGID;
385 if (ia_xvalid & OP_XVALID_CTIME_SET)
386 sa_valid |= MDS_ATTR_CTIME_SET;
387 if (ia_valid & ATTR_OPEN)
388 sa_valid |= MDS_ATTR_FROM_OPEN;
389 if (ia_xvalid & OP_XVALID_BLOCKS)
390 sa_valid |= MDS_ATTR_BLOCKS;
391 if (ia_xvalid & OP_XVALID_OWNEROVERRIDE)
392 /* NFSD hack (see bug 5781) */
393 sa_valid |= MDS_OPEN_OWNEROVERRIDE;
394 if (ia_xvalid & OP_XVALID_PROJID)
395 sa_valid |= MDS_ATTR_PROJID;
396 if (ia_xvalid & OP_XVALID_LAZYSIZE)
397 sa_valid |= MDS_ATTR_LSIZE;
398 if (ia_xvalid & OP_XVALID_LAZYBLOCKS)
399 sa_valid |= MDS_ATTR_LBLOCKS;
404 static void mdc_setattr_pack_rec(struct mdt_rec_setattr *rec,
405 struct md_op_data *op_data)
407 rec->sa_opcode = REINT_SETATTR;
408 rec->sa_fsuid = from_kuid(&init_user_ns, current_fsuid());
409 rec->sa_fsgid = from_kgid(&init_user_ns, current_fsgid());
410 rec->sa_cap = ll_capability_u32(current_cap());
411 rec->sa_suppgid = -1;
413 rec->sa_fid = op_data->op_fid1;
414 rec->sa_valid = mdc_attr_pack(op_data->op_attr.ia_valid,
416 rec->sa_mode = op_data->op_attr.ia_mode;
417 rec->sa_uid = from_kuid(&init_user_ns, op_data->op_attr.ia_uid);
418 rec->sa_gid = from_kgid(&init_user_ns, op_data->op_attr.ia_gid);
419 rec->sa_projid = op_data->op_projid;
420 rec->sa_size = op_data->op_attr.ia_size;
421 rec->sa_blocks = op_data->op_attr_blocks;
422 rec->sa_atime = op_data->op_attr.ia_atime.tv_sec;
423 rec->sa_mtime = op_data->op_attr.ia_mtime.tv_sec;
424 rec->sa_ctime = op_data->op_attr.ia_ctime.tv_sec;
425 rec->sa_attr_flags = op_data->op_attr_flags;
426 if ((op_data->op_attr.ia_valid & ATTR_GID) &&
427 in_group_p(op_data->op_attr.ia_gid))
429 from_kgid(&init_user_ns, op_data->op_attr.ia_gid);
431 rec->sa_suppgid = op_data->op_suppgids[0];
433 rec->sa_bias = op_data->op_bias;
436 static void mdc_ioepoch_pack(struct mdt_ioepoch *epoch,
437 struct md_op_data *op_data)
439 epoch->mio_open_handle = op_data->op_open_handle;
440 epoch->mio_unused1 = 0;
441 epoch->mio_unused2 = 0;
442 epoch->mio_padding = 0;
445 void mdc_setattr_pack(struct req_capsule *pill, struct md_op_data *op_data,
446 void *ea, size_t ealen)
448 struct mdt_rec_setattr *rec;
449 struct lov_user_md *lum = NULL;
451 BUILD_BUG_ON(sizeof(struct mdt_rec_reint) !=
452 sizeof(struct mdt_rec_setattr));
453 rec = req_capsule_client_get(pill, &RMF_REC_REINT);
454 mdc_setattr_pack_rec(rec, op_data);
459 lum = req_capsule_client_get(pill, &RMF_EADATA);
460 if (ea == NULL) { /* Remove LOV EA */
461 lum->lmm_magic = cpu_to_le32(LOV_USER_MAGIC_V1);
462 lum->lmm_stripe_size = 0;
463 lum->lmm_stripe_count = 0;
464 lum->lmm_stripe_offset =
465 (typeof(lum->lmm_stripe_offset))LOV_OFFSET_DEFAULT;
467 memcpy(lum, ea, ealen);
471 void mdc_unlink_pack(struct req_capsule *pill, struct md_op_data *op_data,
472 struct sptlrpc_sepol *sepol)
474 struct mdt_rec_unlink *rec;
476 BUILD_BUG_ON(sizeof(struct mdt_rec_reint) !=
477 sizeof(struct mdt_rec_unlink));
478 rec = req_capsule_client_get(pill, &RMF_REC_REINT);
479 LASSERT(rec != NULL);
481 rec->ul_opcode = op_data->op_cli_flags & CLI_RM_ENTRY ?
482 REINT_RMENTRY : REINT_UNLINK;
483 rec->ul_fsuid = op_data->op_fsuid;
484 rec->ul_fsgid = op_data->op_fsgid;
485 rec->ul_cap = ll_capability_u32(op_data->op_cap);
486 rec->ul_mode = op_data->op_mode;
487 rec->ul_suppgid1 = op_data->op_suppgids[0];
488 rec->ul_suppgid2 = -1;
489 rec->ul_fid1 = op_data->op_fid1;
490 rec->ul_fid2 = op_data->op_fid2;
491 rec->ul_time = op_data->op_mod_time;
492 rec->ul_bias = op_data->op_bias;
494 mdc_pack_name(pill, &RMF_NAME, op_data->op_name, op_data->op_namelen);
496 /* pack SELinux policy info if any */
497 mdc_file_sepol_pack(pill, sepol);
500 void mdc_link_pack(struct req_capsule *pill, struct md_op_data *op_data,
501 struct sptlrpc_sepol *sepol)
503 struct mdt_rec_link *rec;
505 BUILD_BUG_ON(sizeof(struct mdt_rec_reint) !=
506 sizeof(struct mdt_rec_link));
507 rec = req_capsule_client_get(pill, &RMF_REC_REINT);
508 LASSERT(rec != NULL);
510 rec->lk_opcode = REINT_LINK;
511 rec->lk_fsuid = op_data->op_fsuid; /* current->fsuid; */
512 rec->lk_fsgid = op_data->op_fsgid; /* current->fsgid; */
513 rec->lk_cap = ll_capability_u32(op_data->op_cap);
514 rec->lk_suppgid1 = op_data->op_suppgids[0];
515 rec->lk_suppgid2 = op_data->op_suppgids[1];
516 rec->lk_fid1 = op_data->op_fid1;
517 rec->lk_fid2 = op_data->op_fid2;
518 rec->lk_time = op_data->op_mod_time;
519 rec->lk_bias = op_data->op_bias;
521 mdc_pack_name(pill, &RMF_NAME, op_data->op_name, op_data->op_namelen);
523 /* pack SELinux policy info if any */
524 mdc_file_sepol_pack(pill, sepol);
527 static void mdc_close_intent_pack(struct req_capsule *pill,
528 struct md_op_data *op_data)
530 struct close_data *data;
531 struct ldlm_lock *lock;
532 enum mds_op_bias bias = op_data->op_bias;
534 if (!(bias & (MDS_CLOSE_INTENT | MDS_CLOSE_MIGRATE)))
537 data = req_capsule_client_get(pill, &RMF_CLOSE_DATA);
538 LASSERT(data != NULL);
540 lock = ldlm_handle2lock(&op_data->op_lease_handle);
542 data->cd_handle = lock->l_remote_handle;
545 ldlm_cli_cancel(&op_data->op_lease_handle, LCF_LOCAL);
547 data->cd_data_version = op_data->op_data_version;
548 data->cd_fid = op_data->op_fid2;
550 if (bias & MDS_CLOSE_LAYOUT_SPLIT) {
551 data->cd_mirror_id = op_data->op_mirror_id;
552 } else if (bias & MDS_CLOSE_RESYNC_DONE) {
553 struct close_data_resync_done *sync = &data->cd_resync;
555 BUILD_BUG_ON(sizeof(data->cd_resync) >
556 sizeof(data->cd_reserved));
557 sync->resync_count = op_data->op_data_size / sizeof(__u32);
558 if (sync->resync_count <= INLINE_RESYNC_ARRAY_SIZE) {
559 memcpy(sync->resync_ids_inline, op_data->op_data,
560 op_data->op_data_size);
562 size_t count = sync->resync_count;
564 memcpy(req_capsule_client_get(pill, &RMF_U32),
565 op_data->op_data, count * sizeof(__u32));
567 } else if (bias & MDS_PCC_ATTACH) {
568 data->cd_archive_id = op_data->op_archive_id;
569 } else if (bias & MDS_CLOSE_LAYOUT_SWAP) {
570 data->cd_data_version2 = op_data->op_data_version2;
574 void mdc_rename_pack(struct req_capsule *pill, struct md_op_data *op_data,
575 const char *old, size_t oldlen,
576 const char *new, size_t newlen,
577 struct sptlrpc_sepol *sepol)
579 struct mdt_rec_rename *rec;
581 BUILD_BUG_ON(sizeof(struct mdt_rec_reint) !=
582 sizeof(struct mdt_rec_rename));
583 rec = req_capsule_client_get(pill, &RMF_REC_REINT);
585 /* XXX do something about time, uid, gid */
586 rec->rn_opcode = REINT_RENAME;
587 rec->rn_fsuid = op_data->op_fsuid;
588 rec->rn_fsgid = op_data->op_fsgid;
589 rec->rn_cap = ll_capability_u32(op_data->op_cap);
590 rec->rn_suppgid1 = op_data->op_suppgids[0];
591 rec->rn_suppgid2 = op_data->op_suppgids[1];
592 rec->rn_fid1 = op_data->op_fid1;
593 rec->rn_fid2 = op_data->op_fid2;
594 rec->rn_time = op_data->op_mod_time;
595 rec->rn_mode = op_data->op_mode;
596 rec->rn_bias = op_data->op_bias;
598 mdc_pack_name(pill, &RMF_NAME, old, oldlen);
601 mdc_pack_name(pill, &RMF_SYMTGT, new, newlen);
603 /* pack SELinux policy info if any */
604 mdc_file_sepol_pack(pill, sepol);
607 void mdc_migrate_pack(struct req_capsule *pill, struct md_op_data *op_data,
608 const char *name, size_t namelen)
610 struct mdt_rec_rename *rec;
613 BUILD_BUG_ON(sizeof(struct mdt_rec_reint) !=
614 sizeof(struct mdt_rec_rename));
615 rec = req_capsule_client_get(pill, &RMF_REC_REINT);
617 rec->rn_opcode = REINT_MIGRATE;
618 rec->rn_fsuid = op_data->op_fsuid;
619 rec->rn_fsgid = op_data->op_fsgid;
620 rec->rn_cap = ll_capability_u32(op_data->op_cap);
621 rec->rn_suppgid1 = op_data->op_suppgids[0];
622 rec->rn_suppgid2 = op_data->op_suppgids[1];
623 rec->rn_fid1 = op_data->op_fid1;
624 rec->rn_fid2 = op_data->op_fid4;
625 rec->rn_time = op_data->op_mod_time;
626 rec->rn_mode = op_data->op_mode;
627 rec->rn_bias = op_data->op_bias;
629 mdc_pack_name(pill, &RMF_NAME, name, namelen);
631 if (op_data->op_bias & MDS_CLOSE_MIGRATE) {
632 struct mdt_ioepoch *epoch;
634 mdc_close_intent_pack(pill, op_data);
635 epoch = req_capsule_client_get(pill, &RMF_MDT_EPOCH);
636 mdc_ioepoch_pack(epoch, op_data);
639 ea = req_capsule_client_get(pill, &RMF_EADATA);
640 memcpy(ea, op_data->op_data, op_data->op_data_size);
643 void mdc_getattr_pack(struct req_capsule *pill, __u64 valid, __u32 flags,
644 struct md_op_data *op_data, size_t ea_size)
646 struct mdt_body *b = req_capsule_client_get(pill, &RMF_MDT_BODY);
648 b->mbo_valid = valid;
649 if (op_data->op_bias & MDS_CROSS_REF)
650 b->mbo_valid |= OBD_MD_FLCROSSREF;
651 if (op_data->op_bias & MDS_FID_OP)
652 b->mbo_valid |= OBD_MD_NAMEHASH;
653 b->mbo_eadatasize = ea_size;
654 b->mbo_flags = flags;
655 __mdc_pack_body(b, op_data->op_suppgids[0]);
657 b->mbo_fid1 = op_data->op_fid1;
658 b->mbo_fid2 = op_data->op_fid2;
659 b->mbo_valid |= OBD_MD_FLID;
661 if (op_data->op_name != NULL)
662 mdc_pack_name(pill, &RMF_NAME, op_data->op_name,
663 op_data->op_namelen);
666 void mdc_close_pack(struct req_capsule *pill, struct md_op_data *op_data)
668 struct mdt_ioepoch *epoch;
669 struct mdt_rec_setattr *rec;
671 epoch = req_capsule_client_get(pill, &RMF_MDT_EPOCH);
672 rec = req_capsule_client_get(pill, &RMF_REC_REINT);
674 mdc_setattr_pack_rec(rec, op_data);
676 * The client will zero out local timestamps when losing the IBITS lock
677 * so any new RPC timestamps will update the client inode's timestamps.
678 * There was a defect on the server side which allowed the atime to be
679 * overwritten by a zeroed-out atime packed into the close RPC.
681 * Proactively clear the MDS_ATTR_ATIME flag in the RPC in this case
682 * to avoid zeroing the atime on old unpatched servers. See LU-8041.
684 if (rec->sa_atime == 0)
685 rec->sa_valid &= ~MDS_ATTR_ATIME;
687 mdc_ioepoch_pack(epoch, op_data);
688 mdc_close_intent_pack(pill, op_data);