Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 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 |
Oleg Drokin | 6a5b99a | 2016-06-14 23:33:40 -0400 | [diff] [blame] | 18 | * http://www.gnu.org/licenses/gpl-2.0.html |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 19 | * |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 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 | * |
Andreas Dilger | 1dc563a | 2015-11-08 18:09:37 -0500 | [diff] [blame] | 26 | * Copyright (c) 2011, 2015, Intel Corporation. |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 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 |
Greg Kroah-Hartman | 0593230 | 2014-07-11 22:04:56 -0700 | [diff] [blame] | 34 | #include "../include/lustre_net.h" |
| 35 | #include "../include/lustre/lustre_idl.h" |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 36 | #include "mdc_internal.h" |
| 37 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 38 | static void __mdc_pack_body(struct mdt_body *b, __u32 suppgid) |
| 39 | { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 40 | b->suppgid = suppgid; |
Peng Tao | 4b1a25f | 2013-07-15 22:27:14 +0800 | [diff] [blame] | 41 | b->uid = from_kuid(&init_user_ns, current_uid()); |
| 42 | b->gid = from_kgid(&init_user_ns, current_gid()); |
| 43 | b->fsuid = from_kuid(&init_user_ns, current_fsuid()); |
| 44 | b->fsgid = from_kgid(&init_user_ns, current_fsgid()); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 45 | b->capability = cfs_curproc_cap_pack(); |
| 46 | } |
| 47 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 48 | void mdc_is_subdir_pack(struct ptlrpc_request *req, const struct lu_fid *pfid, |
| 49 | const struct lu_fid *cfid, int flags) |
| 50 | { |
| 51 | struct mdt_body *b = req_capsule_client_get(&req->rq_pill, |
| 52 | &RMF_MDT_BODY); |
| 53 | |
| 54 | if (pfid) { |
| 55 | b->fid1 = *pfid; |
| 56 | b->valid = OBD_MD_FLID; |
| 57 | } |
| 58 | if (cfid) |
| 59 | b->fid2 = *cfid; |
| 60 | b->flags = flags; |
| 61 | } |
| 62 | |
| 63 | void mdc_swap_layouts_pack(struct ptlrpc_request *req, |
| 64 | struct md_op_data *op_data) |
| 65 | { |
| 66 | struct mdt_body *b = req_capsule_client_get(&req->rq_pill, |
| 67 | &RMF_MDT_BODY); |
| 68 | |
| 69 | __mdc_pack_body(b, op_data->op_suppgids[0]); |
| 70 | b->fid1 = op_data->op_fid1; |
| 71 | b->fid2 = op_data->op_fid2; |
| 72 | b->valid |= OBD_MD_FLID; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 73 | } |
| 74 | |
Oleg Drokin | ef2e0f5 | 2015-09-27 16:45:46 -0400 | [diff] [blame] | 75 | void mdc_pack_body(struct ptlrpc_request *req, const struct lu_fid *fid, |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 76 | __u64 valid, int ea_size, __u32 suppgid, int flags) |
| 77 | { |
| 78 | struct mdt_body *b = req_capsule_client_get(&req->rq_pill, |
| 79 | &RMF_MDT_BODY); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 80 | b->valid = valid; |
| 81 | b->eadatasize = ea_size; |
| 82 | b->flags = flags; |
| 83 | __mdc_pack_body(b, suppgid); |
| 84 | if (fid) { |
| 85 | b->fid1 = *fid; |
| 86 | b->valid |= OBD_MD_FLID; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 87 | } |
| 88 | } |
| 89 | |
| 90 | void mdc_readdir_pack(struct ptlrpc_request *req, __u64 pgoff, |
Oleg Drokin | ef2e0f5 | 2015-09-27 16:45:46 -0400 | [diff] [blame] | 91 | __u32 size, const struct lu_fid *fid) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 92 | { |
| 93 | struct mdt_body *b = req_capsule_client_get(&req->rq_pill, |
| 94 | &RMF_MDT_BODY); |
| 95 | b->fid1 = *fid; |
| 96 | b->valid |= OBD_MD_FLID; |
| 97 | b->size = pgoff; /* !! */ |
| 98 | b->nlink = size; /* !! */ |
| 99 | __mdc_pack_body(b, -1); |
| 100 | b->mode = LUDA_FID | LUDA_TYPE; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 101 | } |
| 102 | |
| 103 | /* packing of MDS records */ |
| 104 | void mdc_create_pack(struct ptlrpc_request *req, struct md_op_data *op_data, |
| 105 | const void *data, int datalen, __u32 mode, |
| 106 | __u32 uid, __u32 gid, cfs_cap_t cap_effective, __u64 rdev) |
| 107 | { |
| 108 | struct mdt_rec_create *rec; |
| 109 | char *tmp; |
| 110 | __u64 flags; |
| 111 | |
| 112 | CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_create)); |
| 113 | rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT); |
| 114 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 115 | rec->cr_opcode = REINT_CREATE; |
| 116 | rec->cr_fsuid = uid; |
| 117 | rec->cr_fsgid = gid; |
| 118 | rec->cr_cap = cap_effective; |
| 119 | rec->cr_fid1 = op_data->op_fid1; |
| 120 | rec->cr_fid2 = op_data->op_fid2; |
| 121 | rec->cr_mode = mode; |
| 122 | rec->cr_rdev = rdev; |
| 123 | rec->cr_time = op_data->op_mod_time; |
| 124 | rec->cr_suppgid1 = op_data->op_suppgids[0]; |
| 125 | rec->cr_suppgid2 = op_data->op_suppgids[1]; |
| 126 | flags = op_data->op_flags & MF_SOM_LOCAL_FLAGS; |
| 127 | if (op_data->op_bias & MDS_CREATE_VOLATILE) |
| 128 | flags |= MDS_OPEN_VOLATILE; |
| 129 | set_mrc_cr_flags(rec, flags); |
| 130 | rec->cr_bias = op_data->op_bias; |
| 131 | rec->cr_umask = current_umask(); |
| 132 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 133 | tmp = req_capsule_client_get(&req->rq_pill, &RMF_NAME); |
| 134 | LOGL0(op_data->op_name, op_data->op_namelen, tmp); |
| 135 | |
| 136 | if (data) { |
| 137 | tmp = req_capsule_client_get(&req->rq_pill, &RMF_EADATA); |
| 138 | memcpy(tmp, data, datalen); |
| 139 | } |
| 140 | } |
| 141 | |
Jinshan Xiong | d3a8a4e | 2013-11-19 21:23:41 +0800 | [diff] [blame] | 142 | static __u64 mds_pack_open_flags(__u64 flags, __u32 mode) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 143 | { |
| 144 | __u64 cr_flags = (flags & (FMODE_READ | FMODE_WRITE | |
| 145 | MDS_OPEN_HAS_EA | MDS_OPEN_HAS_OBJS | |
| 146 | MDS_OPEN_OWNEROVERRIDE | MDS_OPEN_LOCK | |
Jinshan Xiong | 48d23e6 | 2013-12-03 21:58:48 +0800 | [diff] [blame] | 147 | MDS_OPEN_BY_FID | MDS_OPEN_LEASE | |
| 148 | MDS_OPEN_RELEASE)); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 149 | if (flags & O_CREAT) |
| 150 | cr_flags |= MDS_OPEN_CREAT; |
| 151 | if (flags & O_EXCL) |
| 152 | cr_flags |= MDS_OPEN_EXCL; |
| 153 | if (flags & O_TRUNC) |
| 154 | cr_flags |= MDS_OPEN_TRUNC; |
| 155 | if (flags & O_APPEND) |
| 156 | cr_flags |= MDS_OPEN_APPEND; |
| 157 | if (flags & O_SYNC) |
| 158 | cr_flags |= MDS_OPEN_SYNC; |
| 159 | if (flags & O_DIRECTORY) |
| 160 | cr_flags |= MDS_OPEN_DIRECTORY; |
Juston Li | 962dbfd6 | 2014-11-18 17:03:51 -0800 | [diff] [blame] | 161 | if (flags & __FMODE_EXEC) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 162 | cr_flags |= MDS_FMODE_EXEC; |
Andreas Dilger | 38585cc | 2014-02-11 02:52:05 -0700 | [diff] [blame] | 163 | if (cl_is_lov_delay_create(flags)) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 164 | cr_flags |= MDS_OPEN_DELAY_CREATE; |
| 165 | |
Peng Tao | 7d5ed06 | 2013-06-03 21:58:17 +0800 | [diff] [blame] | 166 | if (flags & O_NONBLOCK) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 167 | cr_flags |= MDS_OPEN_NORESTORE; |
| 168 | |
| 169 | return cr_flags; |
| 170 | } |
| 171 | |
| 172 | /* packing of MDS records */ |
| 173 | void mdc_open_pack(struct ptlrpc_request *req, struct md_op_data *op_data, |
Jinshan Xiong | d3a8a4e | 2013-11-19 21:23:41 +0800 | [diff] [blame] | 174 | __u32 mode, __u64 rdev, __u64 flags, const void *lmm, |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 175 | int lmmlen) |
| 176 | { |
| 177 | struct mdt_rec_create *rec; |
| 178 | char *tmp; |
| 179 | __u64 cr_flags; |
| 180 | |
| 181 | CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_create)); |
| 182 | rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT); |
| 183 | |
| 184 | /* XXX do something about time, uid, gid */ |
| 185 | rec->cr_opcode = REINT_OPEN; |
Peng Tao | 4b1a25f | 2013-07-15 22:27:14 +0800 | [diff] [blame] | 186 | rec->cr_fsuid = from_kuid(&init_user_ns, current_fsuid()); |
| 187 | rec->cr_fsgid = from_kgid(&init_user_ns, current_fsgid()); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 188 | rec->cr_cap = cfs_curproc_cap_pack(); |
Rickard Strandqvist | cc1cf0e | 2014-12-17 23:42:53 +0100 | [diff] [blame] | 189 | rec->cr_fid1 = op_data->op_fid1; |
| 190 | rec->cr_fid2 = op_data->op_fid2; |
| 191 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 192 | rec->cr_mode = mode; |
| 193 | cr_flags = mds_pack_open_flags(flags, mode); |
| 194 | rec->cr_rdev = rdev; |
| 195 | rec->cr_time = op_data->op_mod_time; |
| 196 | rec->cr_suppgid1 = op_data->op_suppgids[0]; |
| 197 | rec->cr_suppgid2 = op_data->op_suppgids[1]; |
| 198 | rec->cr_bias = op_data->op_bias; |
| 199 | rec->cr_umask = current_umask(); |
Jinshan Xiong | d3a8a4e | 2013-11-19 21:23:41 +0800 | [diff] [blame] | 200 | rec->cr_old_handle = op_data->op_handle; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 201 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 202 | if (op_data->op_name) { |
| 203 | tmp = req_capsule_client_get(&req->rq_pill, &RMF_NAME); |
| 204 | LOGL0(op_data->op_name, op_data->op_namelen, tmp); |
| 205 | if (op_data->op_bias & MDS_CREATE_VOLATILE) |
| 206 | cr_flags |= MDS_OPEN_VOLATILE; |
| 207 | } |
| 208 | |
| 209 | if (lmm) { |
| 210 | cr_flags |= MDS_OPEN_HAS_EA; |
| 211 | tmp = req_capsule_client_get(&req->rq_pill, &RMF_EADATA); |
| 212 | memcpy(tmp, lmm, lmmlen); |
| 213 | } |
| 214 | set_mrc_cr_flags(rec, cr_flags); |
| 215 | } |
| 216 | |
Srikrishan Malik | 982ec91 | 2014-08-11 23:57:29 +0530 | [diff] [blame] | 217 | static inline __u64 attr_pack(unsigned int ia_valid) |
| 218 | { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 219 | __u64 sa_valid = 0; |
| 220 | |
| 221 | if (ia_valid & ATTR_MODE) |
| 222 | sa_valid |= MDS_ATTR_MODE; |
| 223 | if (ia_valid & ATTR_UID) |
| 224 | sa_valid |= MDS_ATTR_UID; |
| 225 | if (ia_valid & ATTR_GID) |
| 226 | sa_valid |= MDS_ATTR_GID; |
| 227 | if (ia_valid & ATTR_SIZE) |
| 228 | sa_valid |= MDS_ATTR_SIZE; |
| 229 | if (ia_valid & ATTR_ATIME) |
| 230 | sa_valid |= MDS_ATTR_ATIME; |
| 231 | if (ia_valid & ATTR_MTIME) |
| 232 | sa_valid |= MDS_ATTR_MTIME; |
| 233 | if (ia_valid & ATTR_CTIME) |
| 234 | sa_valid |= MDS_ATTR_CTIME; |
| 235 | if (ia_valid & ATTR_ATIME_SET) |
| 236 | sa_valid |= MDS_ATTR_ATIME_SET; |
| 237 | if (ia_valid & ATTR_MTIME_SET) |
| 238 | sa_valid |= MDS_ATTR_MTIME_SET; |
| 239 | if (ia_valid & ATTR_FORCE) |
| 240 | sa_valid |= MDS_ATTR_FORCE; |
| 241 | if (ia_valid & ATTR_ATTR_FLAG) |
| 242 | sa_valid |= MDS_ATTR_ATTR_FLAG; |
| 243 | if (ia_valid & ATTR_KILL_SUID) |
| 244 | sa_valid |= MDS_ATTR_KILL_SUID; |
| 245 | if (ia_valid & ATTR_KILL_SGID) |
| 246 | sa_valid |= MDS_ATTR_KILL_SGID; |
| 247 | if (ia_valid & ATTR_CTIME_SET) |
| 248 | sa_valid |= MDS_ATTR_CTIME_SET; |
Oleg Drokin | e56e17e | 2015-07-30 18:28:04 -0400 | [diff] [blame] | 249 | if (ia_valid & ATTR_OPEN) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 250 | sa_valid |= MDS_ATTR_FROM_OPEN; |
| 251 | if (ia_valid & ATTR_BLOCKS) |
| 252 | sa_valid |= MDS_ATTR_BLOCKS; |
| 253 | if (ia_valid & MDS_OPEN_OWNEROVERRIDE) |
| 254 | /* NFSD hack (see bug 5781) */ |
| 255 | sa_valid |= MDS_OPEN_OWNEROVERRIDE; |
| 256 | return sa_valid; |
| 257 | } |
| 258 | |
| 259 | static void mdc_setattr_pack_rec(struct mdt_rec_setattr *rec, |
| 260 | struct md_op_data *op_data) |
| 261 | { |
| 262 | rec->sa_opcode = REINT_SETATTR; |
Peng Tao | 4b1a25f | 2013-07-15 22:27:14 +0800 | [diff] [blame] | 263 | rec->sa_fsuid = from_kuid(&init_user_ns, current_fsuid()); |
| 264 | rec->sa_fsgid = from_kgid(&init_user_ns, current_fsgid()); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 265 | rec->sa_cap = cfs_curproc_cap_pack(); |
| 266 | rec->sa_suppgid = -1; |
| 267 | |
| 268 | rec->sa_fid = op_data->op_fid1; |
| 269 | rec->sa_valid = attr_pack(op_data->op_attr.ia_valid); |
| 270 | rec->sa_mode = op_data->op_attr.ia_mode; |
Peng Tao | 4b1a25f | 2013-07-15 22:27:14 +0800 | [diff] [blame] | 271 | rec->sa_uid = from_kuid(&init_user_ns, op_data->op_attr.ia_uid); |
| 272 | rec->sa_gid = from_kgid(&init_user_ns, op_data->op_attr.ia_gid); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 273 | rec->sa_size = op_data->op_attr.ia_size; |
| 274 | rec->sa_blocks = op_data->op_attr_blocks; |
| 275 | rec->sa_atime = LTIME_S(op_data->op_attr.ia_atime); |
| 276 | rec->sa_mtime = LTIME_S(op_data->op_attr.ia_mtime); |
| 277 | rec->sa_ctime = LTIME_S(op_data->op_attr.ia_ctime); |
Oleg Drokin | bb41292 | 2016-03-30 19:48:38 -0400 | [diff] [blame] | 278 | rec->sa_attr_flags = op_data->op_attr_flags; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 279 | if ((op_data->op_attr.ia_valid & ATTR_GID) && |
Peng Tao | 4b1a25f | 2013-07-15 22:27:14 +0800 | [diff] [blame] | 280 | in_group_p(op_data->op_attr.ia_gid)) |
| 281 | rec->sa_suppgid = |
| 282 | from_kgid(&init_user_ns, op_data->op_attr.ia_gid); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 283 | else |
| 284 | rec->sa_suppgid = op_data->op_suppgids[0]; |
| 285 | |
| 286 | rec->sa_bias = op_data->op_bias; |
| 287 | } |
| 288 | |
| 289 | static void mdc_ioepoch_pack(struct mdt_ioepoch *epoch, |
| 290 | struct md_op_data *op_data) |
| 291 | { |
| 292 | memcpy(&epoch->handle, &op_data->op_handle, sizeof(epoch->handle)); |
| 293 | epoch->ioepoch = op_data->op_ioepoch; |
| 294 | epoch->flags = op_data->op_flags & MF_SOM_LOCAL_FLAGS; |
| 295 | } |
| 296 | |
| 297 | void mdc_setattr_pack(struct ptlrpc_request *req, struct md_op_data *op_data, |
| 298 | void *ea, int ealen, void *ea2, int ea2len) |
| 299 | { |
| 300 | struct mdt_rec_setattr *rec; |
| 301 | struct mdt_ioepoch *epoch; |
| 302 | struct lov_user_md *lum = NULL; |
| 303 | |
Srikrishan Malik | 301af90 | 2014-08-11 23:57:31 +0530 | [diff] [blame] | 304 | CLASSERT(sizeof(struct mdt_rec_reint) == |
| 305 | sizeof(struct mdt_rec_setattr)); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 306 | rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT); |
| 307 | mdc_setattr_pack_rec(rec, op_data); |
| 308 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 309 | if (op_data->op_flags & (MF_SOM_CHANGE | MF_EPOCH_OPEN)) { |
| 310 | epoch = req_capsule_client_get(&req->rq_pill, &RMF_MDT_EPOCH); |
| 311 | mdc_ioepoch_pack(epoch, op_data); |
| 312 | } |
| 313 | |
| 314 | if (ealen == 0) |
| 315 | return; |
| 316 | |
| 317 | lum = req_capsule_client_get(&req->rq_pill, &RMF_EADATA); |
Oleg Drokin | 34e3ff9 | 2016-02-16 00:46:53 -0500 | [diff] [blame] | 318 | if (!ea) { /* Remove LOV EA */ |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 319 | lum->lmm_magic = LOV_USER_MAGIC_V1; |
| 320 | lum->lmm_stripe_size = 0; |
| 321 | lum->lmm_stripe_count = 0; |
| 322 | lum->lmm_stripe_offset = (typeof(lum->lmm_stripe_offset))(-1); |
| 323 | } else { |
| 324 | memcpy(lum, ea, ealen); |
| 325 | } |
| 326 | |
| 327 | if (ea2len == 0) |
| 328 | return; |
| 329 | |
| 330 | memcpy(req_capsule_client_get(&req->rq_pill, &RMF_LOGCOOKIES), ea2, |
| 331 | ea2len); |
| 332 | } |
| 333 | |
| 334 | void mdc_unlink_pack(struct ptlrpc_request *req, struct md_op_data *op_data) |
| 335 | { |
| 336 | struct mdt_rec_unlink *rec; |
| 337 | char *tmp; |
| 338 | |
| 339 | CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_unlink)); |
| 340 | rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 341 | |
Srikrishan Malik | 301af90 | 2014-08-11 23:57:31 +0530 | [diff] [blame] | 342 | rec->ul_opcode = op_data->op_cli_flags & CLI_RM_ENTRY ? |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 343 | REINT_RMENTRY : REINT_UNLINK; |
Srikrishan Malik | 301af90 | 2014-08-11 23:57:31 +0530 | [diff] [blame] | 344 | rec->ul_fsuid = op_data->op_fsuid; |
| 345 | rec->ul_fsgid = op_data->op_fsgid; |
| 346 | rec->ul_cap = op_data->op_cap; |
| 347 | rec->ul_mode = op_data->op_mode; |
| 348 | rec->ul_suppgid1 = op_data->op_suppgids[0]; |
| 349 | rec->ul_suppgid2 = -1; |
| 350 | rec->ul_fid1 = op_data->op_fid1; |
| 351 | rec->ul_fid2 = op_data->op_fid2; |
| 352 | rec->ul_time = op_data->op_mod_time; |
| 353 | rec->ul_bias = op_data->op_bias; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 354 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 355 | tmp = req_capsule_client_get(&req->rq_pill, &RMF_NAME); |
Oleg Drokin | 34e3ff9 | 2016-02-16 00:46:53 -0500 | [diff] [blame] | 356 | LASSERT(tmp); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 357 | LOGL0(op_data->op_name, op_data->op_namelen, tmp); |
| 358 | } |
| 359 | |
| 360 | void mdc_link_pack(struct ptlrpc_request *req, struct md_op_data *op_data) |
| 361 | { |
| 362 | struct mdt_rec_link *rec; |
| 363 | char *tmp; |
| 364 | |
| 365 | CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_link)); |
| 366 | rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 367 | |
| 368 | rec->lk_opcode = REINT_LINK; |
Srikrishan Malik | 125ffec | 2014-08-11 23:57:32 +0530 | [diff] [blame] | 369 | rec->lk_fsuid = op_data->op_fsuid; /* current->fsuid; */ |
| 370 | rec->lk_fsgid = op_data->op_fsgid; /* current->fsgid; */ |
| 371 | rec->lk_cap = op_data->op_cap; /* current->cap_effective; */ |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 372 | rec->lk_suppgid1 = op_data->op_suppgids[0]; |
| 373 | rec->lk_suppgid2 = op_data->op_suppgids[1]; |
| 374 | rec->lk_fid1 = op_data->op_fid1; |
| 375 | rec->lk_fid2 = op_data->op_fid2; |
| 376 | rec->lk_time = op_data->op_mod_time; |
| 377 | rec->lk_bias = op_data->op_bias; |
| 378 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 379 | tmp = req_capsule_client_get(&req->rq_pill, &RMF_NAME); |
| 380 | LOGL0(op_data->op_name, op_data->op_namelen, tmp); |
| 381 | } |
| 382 | |
| 383 | void mdc_rename_pack(struct ptlrpc_request *req, struct md_op_data *op_data, |
| 384 | const char *old, int oldlen, const char *new, int newlen) |
| 385 | { |
| 386 | struct mdt_rec_rename *rec; |
| 387 | char *tmp; |
| 388 | |
| 389 | CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_rename)); |
| 390 | rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT); |
| 391 | |
| 392 | /* XXX do something about time, uid, gid */ |
| 393 | rec->rn_opcode = REINT_RENAME; |
| 394 | rec->rn_fsuid = op_data->op_fsuid; |
| 395 | rec->rn_fsgid = op_data->op_fsgid; |
| 396 | rec->rn_cap = op_data->op_cap; |
| 397 | rec->rn_suppgid1 = op_data->op_suppgids[0]; |
| 398 | rec->rn_suppgid2 = op_data->op_suppgids[1]; |
| 399 | rec->rn_fid1 = op_data->op_fid1; |
| 400 | rec->rn_fid2 = op_data->op_fid2; |
| 401 | rec->rn_time = op_data->op_mod_time; |
| 402 | rec->rn_mode = op_data->op_mode; |
| 403 | rec->rn_bias = op_data->op_bias; |
| 404 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 405 | tmp = req_capsule_client_get(&req->rq_pill, &RMF_NAME); |
| 406 | LOGL0(old, oldlen, tmp); |
| 407 | |
| 408 | if (new) { |
| 409 | tmp = req_capsule_client_get(&req->rq_pill, &RMF_SYMTGT); |
| 410 | LOGL0(new, newlen, tmp); |
| 411 | } |
| 412 | } |
| 413 | |
| 414 | void mdc_getattr_pack(struct ptlrpc_request *req, __u64 valid, int flags, |
| 415 | struct md_op_data *op_data, int ea_size) |
| 416 | { |
| 417 | struct mdt_body *b = req_capsule_client_get(&req->rq_pill, |
| 418 | &RMF_MDT_BODY); |
| 419 | |
| 420 | b->valid = valid; |
| 421 | if (op_data->op_bias & MDS_CHECK_SPLIT) |
| 422 | b->valid |= OBD_MD_FLCKSPLIT; |
| 423 | if (op_data->op_bias & MDS_CROSS_REF) |
| 424 | b->valid |= OBD_MD_FLCROSSREF; |
| 425 | b->eadatasize = ea_size; |
| 426 | b->flags = flags; |
| 427 | __mdc_pack_body(b, op_data->op_suppgids[0]); |
| 428 | |
| 429 | b->fid1 = op_data->op_fid1; |
| 430 | b->fid2 = op_data->op_fid2; |
| 431 | b->valid |= OBD_MD_FLID; |
| 432 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 433 | if (op_data->op_name) { |
| 434 | char *tmp = req_capsule_client_get(&req->rq_pill, &RMF_NAME); |
Srikrishan Malik | 7436d07 | 2014-08-11 23:57:33 +0530 | [diff] [blame] | 435 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 436 | LOGL0(op_data->op_name, op_data->op_namelen, tmp); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 437 | } |
| 438 | } |
| 439 | |
Jinshan Xiong | 48d23e6 | 2013-12-03 21:58:48 +0800 | [diff] [blame] | 440 | static void mdc_hsm_release_pack(struct ptlrpc_request *req, |
| 441 | struct md_op_data *op_data) |
| 442 | { |
| 443 | if (op_data->op_bias & MDS_HSM_RELEASE) { |
| 444 | struct close_data *data; |
| 445 | struct ldlm_lock *lock; |
| 446 | |
| 447 | data = req_capsule_client_get(&req->rq_pill, &RMF_CLOSE_DATA); |
Jinshan Xiong | 48d23e6 | 2013-12-03 21:58:48 +0800 | [diff] [blame] | 448 | |
| 449 | lock = ldlm_handle2lock(&op_data->op_lease_handle); |
Oleg Drokin | 34e3ff9 | 2016-02-16 00:46:53 -0500 | [diff] [blame] | 450 | if (lock) { |
Jinshan Xiong | 48d23e6 | 2013-12-03 21:58:48 +0800 | [diff] [blame] | 451 | data->cd_handle = lock->l_remote_handle; |
Jinshan Xiong | ead0280 | 2016-04-04 21:36:51 -0400 | [diff] [blame] | 452 | LDLM_LOCK_PUT(lock); |
Jinshan Xiong | 48d23e6 | 2013-12-03 21:58:48 +0800 | [diff] [blame] | 453 | } |
| 454 | ldlm_cli_cancel(&op_data->op_lease_handle, LCF_LOCAL); |
| 455 | |
| 456 | data->cd_data_version = op_data->op_data_version; |
| 457 | data->cd_fid = op_data->op_fid2; |
| 458 | } |
| 459 | } |
| 460 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 461 | void mdc_close_pack(struct ptlrpc_request *req, struct md_op_data *op_data) |
| 462 | { |
| 463 | struct mdt_ioepoch *epoch; |
| 464 | struct mdt_rec_setattr *rec; |
| 465 | |
| 466 | epoch = req_capsule_client_get(&req->rq_pill, &RMF_MDT_EPOCH); |
| 467 | rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT); |
| 468 | |
| 469 | mdc_setattr_pack_rec(rec, op_data); |
Niu Yawei | aea7ccd | 2016-06-20 16:55:43 -0400 | [diff] [blame] | 470 | /* |
| 471 | * The client will zero out local timestamps when losing the IBITS lock |
| 472 | * so any new RPC timestamps will update the client inode's timestamps. |
| 473 | * There was a defect on the server side which allowed the atime to be |
| 474 | * overwritten by a zeroed-out atime packed into the close RPC. |
| 475 | * |
| 476 | * Proactively clear the MDS_ATTR_ATIME flag in the RPC in this case |
| 477 | * to avoid zeroing the atime on old unpatched servers. See LU-8041. |
| 478 | */ |
| 479 | if (rec->sa_atime == 0) |
| 480 | rec->sa_valid &= ~MDS_ATTR_ATIME; |
| 481 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 482 | mdc_ioepoch_pack(epoch, op_data); |
Jinshan Xiong | 48d23e6 | 2013-12-03 21:58:48 +0800 | [diff] [blame] | 483 | mdc_hsm_release_pack(req, op_data); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 484 | } |
| 485 | |
| 486 | static int mdc_req_avail(struct client_obd *cli, struct mdc_cache_waiter *mcw) |
| 487 | { |
| 488 | int rc; |
Greg Kroah-Hartman | 29aaf49 | 2013-08-02 18:14:51 +0800 | [diff] [blame] | 489 | |
John L. Hammond | 7d53d8f | 2016-03-30 19:48:36 -0400 | [diff] [blame] | 490 | spin_lock(&cli->cl_loi_list_lock); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 491 | rc = list_empty(&mcw->mcw_entry); |
John L. Hammond | 7d53d8f | 2016-03-30 19:48:36 -0400 | [diff] [blame] | 492 | spin_unlock(&cli->cl_loi_list_lock); |
Greg Kroah-Hartman | 0a3bdb0 | 2013-08-03 10:35:28 +0800 | [diff] [blame] | 493 | return rc; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 494 | }; |
| 495 | |
| 496 | /* We record requests in flight in cli->cl_r_in_flight here. |
| 497 | * There is only one write rpc possible in mdc anyway. If this to change |
Oleg Drokin | 1df232e | 2016-02-24 22:00:33 -0500 | [diff] [blame] | 498 | * in the future - the code may need to be revisited. |
| 499 | */ |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 500 | int mdc_enter_request(struct client_obd *cli) |
| 501 | { |
| 502 | int rc = 0; |
| 503 | struct mdc_cache_waiter mcw; |
| 504 | struct l_wait_info lwi = LWI_INTR(LWI_ON_SIGNAL_NOOP, NULL); |
| 505 | |
John L. Hammond | 7d53d8f | 2016-03-30 19:48:36 -0400 | [diff] [blame] | 506 | spin_lock(&cli->cl_loi_list_lock); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 507 | if (cli->cl_r_in_flight >= cli->cl_max_rpcs_in_flight) { |
| 508 | list_add_tail(&mcw.mcw_entry, &cli->cl_cache_waiters); |
| 509 | init_waitqueue_head(&mcw.mcw_waitq); |
John L. Hammond | 7d53d8f | 2016-03-30 19:48:36 -0400 | [diff] [blame] | 510 | spin_unlock(&cli->cl_loi_list_lock); |
Srikrishan Malik | e5e663a | 2014-08-11 23:57:30 +0530 | [diff] [blame] | 511 | rc = l_wait_event(mcw.mcw_waitq, mdc_req_avail(cli, &mcw), |
| 512 | &lwi); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 513 | if (rc) { |
John L. Hammond | 7d53d8f | 2016-03-30 19:48:36 -0400 | [diff] [blame] | 514 | spin_lock(&cli->cl_loi_list_lock); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 515 | if (list_empty(&mcw.mcw_entry)) |
| 516 | cli->cl_r_in_flight--; |
| 517 | list_del_init(&mcw.mcw_entry); |
John L. Hammond | 7d53d8f | 2016-03-30 19:48:36 -0400 | [diff] [blame] | 518 | spin_unlock(&cli->cl_loi_list_lock); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 519 | } |
| 520 | } else { |
| 521 | cli->cl_r_in_flight++; |
John L. Hammond | 7d53d8f | 2016-03-30 19:48:36 -0400 | [diff] [blame] | 522 | spin_unlock(&cli->cl_loi_list_lock); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 523 | } |
| 524 | return rc; |
| 525 | } |
| 526 | |
| 527 | void mdc_exit_request(struct client_obd *cli) |
| 528 | { |
| 529 | struct list_head *l, *tmp; |
| 530 | struct mdc_cache_waiter *mcw; |
| 531 | |
John L. Hammond | 7d53d8f | 2016-03-30 19:48:36 -0400 | [diff] [blame] | 532 | spin_lock(&cli->cl_loi_list_lock); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 533 | cli->cl_r_in_flight--; |
| 534 | list_for_each_safe(l, tmp, &cli->cl_cache_waiters) { |
| 535 | if (cli->cl_r_in_flight >= cli->cl_max_rpcs_in_flight) { |
| 536 | /* No free request slots anymore */ |
| 537 | break; |
| 538 | } |
| 539 | |
| 540 | mcw = list_entry(l, struct mdc_cache_waiter, mcw_entry); |
| 541 | list_del_init(&mcw->mcw_entry); |
| 542 | cli->cl_r_in_flight++; |
| 543 | wake_up(&mcw->mcw_waitq); |
| 544 | } |
| 545 | /* Empty waiting list? Decrease reqs in-flight number */ |
| 546 | |
John L. Hammond | 7d53d8f | 2016-03-30 19:48:36 -0400 | [diff] [blame] | 547 | spin_unlock(&cli->cl_loi_list_lock); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 548 | } |