1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2 * vim:expandtab:shiftwidth=8:tabstop=8:
6 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 only,
10 * as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License version 2 for more details (a copy is included
16 * in the LICENSE file that accompanied this code).
18 * You should have received a copy of the GNU General Public License
19 * version 2 along with this program; If not, see
20 * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
22 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
23 * CA 95054 USA or visit www.sun.com if you need additional information or
29 * Copyright 2008 Sun Microsystems, Inc. All rights reserved
30 * Use is subject to license terms.
33 * This file is part of Lustre, http://www.lustre.org/
34 * Lustre is a trademark of Sun Microsystems, Inc.
37 #define DEBUG_SUBSYSTEM S_MDC
40 # include <liblustre.h>
42 #include <lustre_net.h>
43 #include <lustre/lustre_idl.h>
44 #include "mdc_internal.h"
47 /* some liblustre hackings here */
53 static void mdc_readdir_pack_18(struct ptlrpc_request *req, int offset,
54 __u64 pg_off, __u32 size, struct ll_fid *fid)
59 CLASSERT(sizeof(struct ll_fid) == sizeof(struct lu_fid));
60 CLASSERT(sizeof(struct mds_body) <= sizeof(struct mdt_body));
61 CLASSERT((int)offsetof(struct mds_body, max_cookiesize) ==
62 (int)offsetof(struct mdt_body, max_cookiesize));
65 b = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*b));
66 b->fsuid = cfs_curproc_fsuid();
67 b->fsgid = cfs_curproc_fsgid();
68 b->capability = cfs_curproc_cap_pack();
70 b->size = pg_off; /* !! */
72 b->nlink = size; /* !! */
76 static void mdc_readdir_pack_20(struct ptlrpc_request *req, int offset,
77 __u64 pg_off, __u32 size, struct ll_fid *fid)
82 b = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*b));
83 b->fsuid = cfs_curproc_fsuid();
84 b->fsgid = cfs_curproc_fsgid();
85 b->capability = cfs_curproc_cap_pack();
88 b->fid1 = *((struct lu_fid*)fid);
89 b->valid |= OBD_MD_FLID;
91 b->size = pg_off; /* !! */
93 b->nlink = size; /* !! */
94 b->mode = LUDA_FID | LUDA_TYPE;
98 void mdc_readdir_pack(struct ptlrpc_request *req, int offset,
99 __u64 pg_off, __u32 size, struct ll_fid *fid)
101 if (mdc_req_is_2_0_server(req))
102 mdc_readdir_pack_20(req, offset, pg_off, size, fid);
104 mdc_readdir_pack_18(req, offset, pg_off, size, fid);
107 static void mdc_pack_req_body_18(struct ptlrpc_request *req, int offset,
108 __u64 valid, struct ll_fid *fid, int ea_size,
111 struct mds_body *b = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*b));
118 b->eadatasize = ea_size;
120 b->fsuid = cfs_curproc_fsuid();
121 b->fsgid = cfs_curproc_fsgid();
122 b->capability = cfs_curproc_cap_pack();
126 static void mdc_pack_req_body_20(struct ptlrpc_request *req, int offset,
127 __u64 valid, struct ll_fid *fid, int ea_size,
130 struct mdt_body *b = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*b));
135 b->eadatasize = ea_size;
138 b->fid1 = *((struct lu_fid*)fid);
139 b->valid |= OBD_MD_FLID;
142 b->fsuid = cfs_curproc_fsuid();
143 b->fsgid = cfs_curproc_fsgid();
144 b->capability = cfs_curproc_cap_pack();
148 void mdc_pack_req_body(struct ptlrpc_request *req, int offset,
149 __u64 valid, struct ll_fid *fid, int ea_size,
152 if (mdc_req_is_2_0_server(req))
153 mdc_pack_req_body_20(req, offset, valid, fid, ea_size, flags);
155 mdc_pack_req_body_18(req, offset, valid, fid, ea_size, flags);
158 /* packing of MDS records */
159 static void mdc_create_pack_18(struct ptlrpc_request *req, int offset,
160 struct mdc_op_data *op_data, const void *data,
161 int datalen, __u32 mode, __u32 uid, __u32 gid,
162 cfs_cap_t cap_effective, __u64 rdev)
164 struct mds_rec_create *rec;
168 rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec));
170 rec->cr_opcode = REINT_CREATE;
173 rec->cr_cap = cap_effective;
174 rec->cr_fid = op_data->fid1;
175 memset(&rec->cr_replayfid, 0, sizeof(rec->cr_replayfid));
178 rec->cr_time = op_data->mod_time;
179 rec->cr_suppgid = op_data->suppgids[0];
181 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1, op_data->namelen + 1);
182 LOGL0(op_data->name, op_data->namelen, tmp);
185 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2, datalen);
186 memcpy (tmp, data, datalen);
191 static void mdc_create_pack_20(struct ptlrpc_request *req, int offset,
192 struct mdc_op_data *op_data, const void *data,
193 int datalen, __u32 mode, __u32 uid, __u32 gid,
194 cfs_cap_t cap_effective, __u64 rdev)
196 struct mdt_rec_create *rec;
200 rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec));
202 rec->cr_opcode = REINT_CREATE;
205 rec->cr_cap = cap_effective;
206 memcpy(&rec->cr_fid1, &op_data->fid1, sizeof(op_data->fid1));
207 memcpy(&rec->cr_fid2, &op_data->fid2, sizeof(op_data->fid2));
210 rec->cr_time = op_data->mod_time;
211 rec->cr_suppgid1 = op_data->suppgids[0];
213 /* offset + 1 == capa */
214 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2, op_data->namelen + 1);
215 LOGL0(op_data->name, op_data->namelen, tmp);
218 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 3, datalen);
219 memcpy(tmp, data, datalen);
224 void mdc_create_pack(struct ptlrpc_request *req, int offset,
225 struct mdc_op_data *op_data, const void *data,
226 int datalen, __u32 mode, __u32 uid, __u32 gid,
227 cfs_cap_t cap_effective, __u64 rdev)
229 if (mdc_req_is_2_0_server(req))
230 mdc_create_pack_20(req, offset, op_data, data, datalen,
231 mode, uid, gid, cap_effective, rdev);
233 mdc_create_pack_18(req, offset, op_data, data, datalen,
234 mode, uid, gid, cap_effective, rdev);
237 static __u32 mds_pack_open_flags(__u32 flags, __u32 mode)
239 __u32 cr_flags = (flags & (FMODE_READ | FMODE_WRITE |
240 MDS_OPEN_DELAY_CREATE | MDS_OPEN_HAS_OBJS |
241 MDS_OPEN_OWNEROVERRIDE | MDS_OPEN_LOCK));
243 cr_flags |= MDS_OPEN_CREAT;
245 cr_flags |= MDS_OPEN_EXCL;
247 cr_flags |= MDS_OPEN_TRUNC;
248 if (flags & O_APPEND)
249 cr_flags |= MDS_OPEN_APPEND;
251 cr_flags |= MDS_OPEN_SYNC;
252 if (flags & O_DIRECTORY)
253 cr_flags |= MDS_OPEN_DIRECTORY;
254 if (mode & M_JOIN_FILE)
255 cr_flags |= MDS_OPEN_JOIN_FILE;
257 if (flags & FMODE_EXEC)
258 cr_flags |= MDS_FMODE_EXEC;
263 /* packing of MDS records */
264 static void mdc_join_pack_18(struct ptlrpc_request *req, int offset,
265 struct mdc_op_data *op_data, __u64 head_size)
267 struct mds_rec_join *rec;
270 rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*rec));
271 LASSERT(rec != NULL);
272 rec->jr_fid = op_data->fid2;
273 rec->jr_headsize = head_size;
277 static void mdc_join_pack_20(struct ptlrpc_request *req, int offset,
278 struct mdc_op_data *op_data, __u64 head_size)
280 struct mdt_rec_join *rec;
283 rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*rec));
284 LASSERT(rec != NULL);
285 memcpy(&rec->jr_fid, &op_data->fid2, sizeof(op_data->fid2));
286 rec->jr_headsize = head_size;
290 void mdc_join_pack(struct ptlrpc_request *req, int offset,
291 struct mdc_op_data *op_data, __u64 head_size)
293 if (mdc_req_is_2_0_server(req))
294 mdc_join_pack_20(req, offset, op_data, head_size);
296 mdc_join_pack_18(req, offset, op_data, head_size);
299 static void mdc_open_pack_18(struct ptlrpc_request *req, int offset,
300 struct mdc_op_data *op_data, __u32 mode, __u64 rdev,
301 __u32 flags, const void *lmm, int lmmlen)
303 struct mds_rec_create *rec;
307 rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec));
309 /* XXX do something about time, uid, gid */
310 rec->cr_opcode = REINT_OPEN;
311 rec->cr_fsuid = cfs_curproc_fsuid();
312 rec->cr_fsgid = cfs_curproc_fsgid();
313 rec->cr_cap = cfs_curproc_cap_pack();
314 rec->cr_fid = op_data->fid1;
315 memset(&rec->cr_replayfid, 0, sizeof(rec->cr_replayfid));
317 rec->cr_flags = mds_pack_open_flags(flags, mode);
319 rec->cr_time = op_data->mod_time;
320 rec->cr_suppgid = op_data->suppgids[0];
323 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1,
324 op_data->namelen + 1);
325 LOGL0(op_data->name, op_data->namelen, tmp);
329 rec->cr_flags |= MDS_OPEN_HAS_EA;
331 /*XXX a hack for liblustre to set EA (LL_IOC_LOV_SETSTRIPE) */
332 rec->cr_replayfid = op_data->fid2;
334 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2, lmmlen);
335 memcpy (tmp, lmm, lmmlen);
340 static void mdc_open_pack_20(struct ptlrpc_request *req, int offset,
341 struct mdc_op_data *op_data, __u32 mode, __u64 rdev,
342 __u32 flags, const void *lmm, int lmmlen)
344 struct mdt_rec_create *rec;
348 rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec));
350 /* XXX do something about time, uid, gid */
351 rec->cr_opcode = REINT_OPEN;
352 rec->cr_fsuid = cfs_curproc_fsuid();
353 rec->cr_fsgid = cfs_curproc_fsgid();
354 rec->cr_cap = cfs_curproc_cap_pack();
355 memcpy(&rec->cr_fid1, &op_data->fid1, sizeof(op_data->fid1));
356 memcpy(&rec->cr_fid2, &op_data->fid2, sizeof(op_data->fid2));
358 rec->cr_flags = mds_pack_open_flags(flags, mode);
360 rec->cr_time = op_data->mod_time;
361 rec->cr_suppgid1 = op_data->suppgids[0];
362 rec->cr_suppgid2 = op_data->suppgids[1];
365 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 3,
366 op_data->namelen + 1);
367 CDEBUG(D_INFO, "offset=%d, src=%p(%d):%s, dst=%p\n",
368 offset, op_data->name, op_data->namelen,
371 LOGL0(op_data->name, op_data->namelen, tmp);
375 rec->cr_flags |= MDS_OPEN_HAS_EA;
377 /*XXX a hack for liblustre to set EA (LL_IOC_LOV_SETSTRIPE) */
378 memcpy(&rec->cr_fid2, &op_data->fid2, sizeof(op_data->fid2));
380 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 4, lmmlen);
381 memcpy(tmp, lmm, lmmlen);
386 void mdc_open_pack(struct ptlrpc_request *req, int offset,
387 struct mdc_op_data *op_data, __u32 mode, __u64 rdev,
388 __u32 flags, const void *lmm, int lmmlen)
390 if (mdc_req_is_2_0_server(req))
391 mdc_open_pack_20(req, offset, op_data, mode, rdev,
394 mdc_open_pack_18(req, offset, op_data, mode, rdev,
399 static inline __u64 attr_pack(unsigned int ia_valid) {
402 if (ia_valid & ATTR_MODE)
403 sa_valid |= MDS_ATTR_MODE;
404 if (ia_valid & ATTR_UID)
405 sa_valid |= MDS_ATTR_UID;
406 if (ia_valid & ATTR_GID)
407 sa_valid |= MDS_ATTR_GID;
408 if (ia_valid & ATTR_SIZE)
409 sa_valid |= MDS_ATTR_SIZE;
410 if (ia_valid & ATTR_ATIME)
411 sa_valid |= MDS_ATTR_ATIME;
412 if (ia_valid & ATTR_MTIME)
413 sa_valid |= MDS_ATTR_MTIME;
414 if (ia_valid & ATTR_CTIME)
415 sa_valid |= MDS_ATTR_CTIME;
416 if (ia_valid & ATTR_ATIME_SET)
417 sa_valid |= MDS_ATTR_ATIME_SET;
418 if (ia_valid & ATTR_MTIME_SET)
419 sa_valid |= MDS_ATTR_MTIME_SET;
420 if (ia_valid & ATTR_FORCE)
421 sa_valid |= MDS_ATTR_FORCE;
422 if (ia_valid & ATTR_ATTR_FLAG)
423 sa_valid |= MDS_ATTR_ATTR_FLAG;
424 if (ia_valid & ATTR_KILL_SUID)
425 sa_valid |= MDS_ATTR_KILL_SUID;
426 if (ia_valid & ATTR_KILL_SGID)
427 sa_valid |= MDS_ATTR_KILL_SGID;
428 if (ia_valid & ATTR_CTIME_SET)
429 sa_valid |= MDS_ATTR_CTIME_SET;
430 if (ia_valid & ATTR_FROM_OPEN)
431 sa_valid |= MDS_ATTR_FROM_OPEN;
432 if (ia_valid & MDS_OPEN_OWNEROVERRIDE)
433 /* NFSD hack (see bug 5781) */
434 sa_valid |= MDS_OPEN_OWNEROVERRIDE;
438 void mdc_setattr_pack_18(struct ptlrpc_request *req, int offset,
439 struct mdc_op_data *data, struct iattr *iattr, void *ea,
440 int ealen, void *ea2, int ea2len)
442 struct mds_rec_setattr *rec = lustre_msg_buf(req->rq_reqmsg, offset,
446 rec->sa_opcode = REINT_SETATTR;
447 rec->sa_fsuid = cfs_curproc_fsuid();
448 rec->sa_fsgid = cfs_curproc_fsgid();
449 rec->sa_cap = cfs_curproc_cap_pack();
450 rec->sa_fid = data->fid1;
451 rec->sa_suppgid = -1;
454 rec->sa_valid = attr_pack(iattr->ia_valid);
455 rec->sa_mode = iattr->ia_mode;
456 rec->sa_uid = iattr->ia_uid;
457 rec->sa_gid = iattr->ia_gid;
458 rec->sa_size = iattr->ia_size;
459 rec->sa_atime = LTIME_S(iattr->ia_atime);
460 rec->sa_mtime = LTIME_S(iattr->ia_mtime);
461 rec->sa_ctime = LTIME_S(iattr->ia_ctime);
463 ((struct ll_iattr_struct *)iattr)->ia_attr_flags;
464 if ((iattr->ia_valid & ATTR_GID) && in_group_p(iattr->ia_gid))
465 rec->sa_suppgid = iattr->ia_gid;
467 rec->sa_suppgid = data->suppgids[0];
475 memcpy(lustre_msg_buf(req->rq_reqmsg, offset + 1, ealen), ea, ealen);
481 memcpy(lustre_msg_buf(req->rq_reqmsg, offset + 2, ea2len), ea2, ea2len);
486 static void mdc_setattr_pack_20(struct ptlrpc_request *req, int offset,
487 struct mdc_op_data *data, struct iattr *iattr,
488 void *ea, int ealen, void *ea2, int ea2len)
490 struct mdt_rec_setattr *rec = lustre_msg_buf(req->rq_reqmsg, offset,
494 rec->sa_opcode = REINT_SETATTR;
495 rec->sa_fsuid = cfs_curproc_fsuid();
496 rec->sa_fsgid = cfs_curproc_fsgid();
497 rec->sa_cap = cfs_curproc_cap_pack();
498 memcpy(&rec->sa_fid, &data->fid1, sizeof(data->fid1));
499 rec->sa_suppgid = -1;
502 rec->sa_valid = attr_pack(iattr->ia_valid);
503 rec->sa_mode = iattr->ia_mode;
504 rec->sa_uid = iattr->ia_uid;
505 rec->sa_gid = iattr->ia_gid;
506 rec->sa_size = iattr->ia_size;
507 // rec->sa_blocks = iattr->ia_blocks;
508 rec->sa_atime = LTIME_S(iattr->ia_atime);
509 rec->sa_mtime = LTIME_S(iattr->ia_mtime);
510 rec->sa_ctime = LTIME_S(iattr->ia_ctime);
512 ((struct ll_iattr_struct *)iattr)->ia_attr_flags;
513 if ((iattr->ia_valid & ATTR_GID) && in_group_p(iattr->ia_gid))
514 rec->sa_suppgid = iattr->ia_gid;
516 rec->sa_suppgid = data->suppgids[0];
522 memcpy(lustre_msg_buf(req->rq_reqmsg, offset + 3, ealen), ea, ealen);
528 memcpy(lustre_msg_buf(req->rq_reqmsg, offset + 4, ea2len), ea2, ea2len);
532 void mdc_setattr_pack(struct ptlrpc_request *req, int offset,
533 struct mdc_op_data *data, struct iattr *iattr,
534 void *ea, int ealen, void *ea2, int ea2len)
536 if (mdc_req_is_2_0_server(req))
537 mdc_setattr_pack_20(req, offset, data, iattr,
538 ea, ealen, ea2, ea2len);
540 mdc_setattr_pack_18(req, offset, data, iattr,
541 ea, ealen, ea2, ea2len);
544 static void mdc_unlink_pack_18(struct ptlrpc_request *req, int offset,
545 struct mdc_op_data *data)
547 struct mds_rec_unlink *rec;
551 rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec));
552 LASSERT (rec != NULL);
554 rec->ul_opcode = REINT_UNLINK;
555 rec->ul_fsuid = cfs_curproc_fsuid();
556 rec->ul_fsgid = cfs_curproc_fsgid();
557 rec->ul_cap = cfs_curproc_cap_pack();
558 rec->ul_mode = data->create_mode;
559 rec->ul_suppgid = data->suppgids[0];
560 rec->ul_fid1 = data->fid1;
561 rec->ul_fid2 = data->fid2;
562 rec->ul_time = data->mod_time;
564 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1, data->namelen + 1);
565 LASSERT (tmp != NULL);
566 LOGL0(data->name, data->namelen, tmp);
570 static void mdc_unlink_pack_20(struct ptlrpc_request *req, int offset,
571 struct mdc_op_data *data)
573 struct mdt_rec_unlink *rec;
577 rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec));
578 LASSERT (rec != NULL);
580 rec->ul_opcode = REINT_UNLINK;
581 rec->ul_fsuid = cfs_curproc_fsuid();
582 rec->ul_fsgid = cfs_curproc_fsgid();
583 rec->ul_cap = cfs_curproc_cap_pack();
584 rec->ul_mode = data->create_mode;
585 rec->ul_suppgid1= data->suppgids[0];
586 memcpy(&rec->ul_fid1, &data->fid1, sizeof(data->fid1));
587 memcpy(&rec->ul_fid2, &data->fid2, sizeof(data->fid2));
588 rec->ul_time = data->mod_time;
590 /* NULL capa is skipped. */
592 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2, data->namelen + 1);
593 LASSERT (tmp != NULL);
594 LOGL0(data->name, data->namelen, tmp);
598 void mdc_unlink_pack(struct ptlrpc_request *req, int offset,
599 struct mdc_op_data *data)
601 if (mdc_req_is_2_0_server(req))
602 mdc_unlink_pack_20(req, offset, data);
604 mdc_unlink_pack_18(req, offset, data);
606 static void mdc_link_pack_18(struct ptlrpc_request *req, int offset,
607 struct mdc_op_data *data)
609 struct mds_rec_link *rec;
613 rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec));
615 rec->lk_opcode = REINT_LINK;
616 rec->lk_fsuid = cfs_curproc_fsuid();
617 rec->lk_fsgid = cfs_curproc_fsgid();
618 rec->lk_cap = cfs_curproc_cap_pack();
619 rec->lk_suppgid1 = data->suppgids[0];
620 rec->lk_suppgid2 = data->suppgids[1];
621 rec->lk_fid1 = data->fid1;
622 rec->lk_fid2 = data->fid2;
623 rec->lk_time = data->mod_time;
625 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1, data->namelen + 1);
626 LOGL0(data->name, data->namelen, tmp);
630 static void mdc_link_pack_20(struct ptlrpc_request *req, int offset,
631 struct mdc_op_data *data)
633 struct mdt_rec_link *rec;
637 rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec));
639 rec->lk_opcode = REINT_LINK;
640 rec->lk_fsuid = cfs_curproc_fsuid();
641 rec->lk_fsgid = cfs_curproc_fsgid();
642 rec->lk_cap = cfs_curproc_cap_pack();
643 rec->lk_suppgid1 = data->suppgids[0];
644 rec->lk_suppgid2 = data->suppgids[1];
645 memcpy(&rec->lk_fid1, &data->fid1, sizeof(data->fid1));
646 memcpy(&rec->lk_fid2, &data->fid2, sizeof(data->fid2));
647 rec->lk_time = data->mod_time;
650 /* capa @ offset + 1; */
651 /* capa @ offset + 2; */
653 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 3, data->namelen + 1);
654 LOGL0(data->name, data->namelen, tmp);
658 void mdc_link_pack(struct ptlrpc_request *req, int offset,
659 struct mdc_op_data *data)
661 if (mdc_req_is_2_0_server(req))
662 mdc_link_pack_20(req, offset, data);
664 mdc_link_pack_18(req, offset, data);
667 static void mdc_rename_pack_18(struct ptlrpc_request *req, int offset,
668 struct mdc_op_data *data, const char *old,
669 int oldlen, const char *new, int newlen)
671 struct mds_rec_rename *rec;
675 rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec));
677 /* XXX do something about time, uid, gid */
678 rec->rn_opcode = REINT_RENAME;
679 rec->rn_fsuid = cfs_curproc_fsuid();
680 rec->rn_fsgid = cfs_curproc_fsgid();
681 rec->rn_cap = cfs_curproc_cap_pack();
682 rec->rn_suppgid1 = data->suppgids[0];
683 rec->rn_suppgid2 = data->suppgids[1];
684 rec->rn_fid1 = data->fid1;
685 rec->rn_fid2 = data->fid2;
686 rec->rn_time = data->mod_time;
688 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1, oldlen + 1);
689 LOGL0(old, oldlen, tmp);
692 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2, newlen + 1);
693 LOGL0(new, newlen, tmp);
698 static void mdc_rename_pack_20(struct ptlrpc_request *req, int offset,
699 struct mdc_op_data *data, const char *old,
700 int oldlen, const char *new, int newlen)
702 struct mdt_rec_rename *rec;
706 rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec));
708 /* XXX do something about time, uid, gid */
709 rec->rn_opcode = REINT_RENAME;
710 rec->rn_fsuid = cfs_curproc_fsuid();
711 rec->rn_fsgid = cfs_curproc_fsgid();
712 rec->rn_cap = cfs_curproc_cap_pack();
713 rec->rn_suppgid1 = data->suppgids[0];
714 rec->rn_suppgid2 = data->suppgids[1];
715 memcpy(&rec->rn_fid1, &data->fid1, sizeof(data->fid1));
716 memcpy(&rec->rn_fid2, &data->fid2, sizeof(data->fid2));
717 rec->rn_time = data->mod_time;
718 rec->rn_mode = data->create_mode;
721 /* skip capa @ offset + 1 */
722 /* skip capa @ offset + 2 */
724 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 3, oldlen + 1);
725 LOGL0(old, oldlen, tmp);
728 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 4, newlen + 1);
729 LOGL0(new, newlen, tmp);
734 void mdc_rename_pack(struct ptlrpc_request *req, int offset,
735 struct mdc_op_data *data, const char *old,
736 int oldlen, const char *new, int newlen)
738 if (mdc_req_is_2_0_server(req))
739 mdc_rename_pack_20(req, offset, data, old, oldlen, new, newlen);
741 mdc_rename_pack_18(req, offset, data, old, oldlen, new, newlen);
744 static void mdc_getattr_pack_18(struct ptlrpc_request *req, int offset,
745 __u64 valid, int flags, struct mdc_op_data *data)
750 b = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*b));
752 b->fsuid = cfs_curproc_fsuid();
753 b->fsgid = cfs_curproc_fsgid();
754 b->capability = cfs_curproc_cap_pack();
756 b->flags = flags | MDS_BFLAG_EXT_FLAGS;
757 /* skip MDS_BFLAG_EXT_FLAGS to verify the "client < 1.4.7" case
758 * refer to bug 12848.
760 if (OBD_FAIL_CHECK(OBD_FAIL_MDC_OLD_EXT_FLAGS))
761 b->flags &= ~MDS_BFLAG_EXT_FLAGS;
762 b->suppgid = data->suppgids[0];
764 b->fid1 = data->fid1;
765 b->fid2 = data->fid2;
768 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1,
770 memcpy(tmp, data->name, data->namelen);
776 static void mdc_getattr_pack_20(struct ptlrpc_request *req, int offset,
777 __u64 valid, int flags, struct mdc_op_data *data)
782 b = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*b));
784 b->fsuid = cfs_curproc_fsuid();
785 b->fsgid = cfs_curproc_fsgid();
786 b->capability = cfs_curproc_cap_pack();
788 b->flags = flags | MDS_BFLAG_EXT_FLAGS;
789 b->suppgid = data->suppgids[0];
791 memcpy(&b->fid1, &data->fid1, sizeof(data->fid1));
792 memcpy(&b->fid2, &data->fid2, sizeof(data->fid2));
793 b->valid |= OBD_MD_FLID;
796 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2,
799 LOGL0(data->name, data->namelen, tmp);
804 void mdc_getattr_pack(struct ptlrpc_request *req, int offset,
805 __u64 valid, int flags, struct mdc_op_data *data)
807 if (mdc_req_is_2_0_server(req))
808 mdc_getattr_pack_20(req, offset, valid, flags, data);
810 mdc_getattr_pack_18(req, offset, valid, flags, data);
812 static void mdc_close_pack_18(struct ptlrpc_request *req, int offset,
813 struct mdc_op_data *data,
814 struct obdo *oa, __u64 valid,
815 struct obd_client_handle *och)
817 struct mds_body *body;
820 body = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*body));
822 body->fid1 = data->fid1;
823 memcpy(&body->handle, &och->och_fh, sizeof(body->handle));
824 if (oa->o_valid & OBD_MD_FLATIME) {
825 body->atime = oa->o_atime;
826 body->valid |= OBD_MD_FLATIME;
828 if (oa->o_valid & OBD_MD_FLMTIME) {
829 body->mtime = oa->o_mtime;
830 body->valid |= OBD_MD_FLMTIME;
832 if (oa->o_valid & OBD_MD_FLCTIME) {
833 body->ctime = oa->o_ctime;
834 body->valid |= OBD_MD_FLCTIME;
836 if (oa->o_valid & OBD_MD_FLSIZE) {
837 body->size = oa->o_size;
838 body->valid |= OBD_MD_FLSIZE;
840 if (oa->o_valid & OBD_MD_FLBLOCKS) {
841 body->blocks = oa->o_blocks;
842 body->valid |= OBD_MD_FLBLOCKS;
844 if (oa->o_valid & OBD_MD_FLFLAGS) {
845 body->flags = oa->o_flags;
846 body->valid |= OBD_MD_FLFLAGS;
851 static void mdc_close_pack_20(struct ptlrpc_request *req, int offset,
852 struct mdc_op_data *data,
853 struct obdo *oa, __u64 valid,
854 struct obd_client_handle *och)
856 struct mdt_epoch *epoch;
857 struct mdt_rec_setattr *rec;
860 epoch = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*epoch));
861 rec = lustre_msg_buf(req->rq_reqmsg, offset + 1, sizeof(*rec));
863 rec->sa_opcode = REINT_SETATTR;
864 rec->sa_fsuid = cfs_curproc_fsuid();
865 rec->sa_fsgid = cfs_curproc_fsgid();
866 rec->sa_cap = cfs_curproc_cap_pack();
867 rec->sa_suppgid = -1;
869 memcpy(&rec->sa_fid, &data->fid1, sizeof(data->fid1));
871 if (oa->o_valid & OBD_MD_FLATIME) {
872 rec->sa_atime = oa->o_atime;
873 rec->sa_valid |= MDS_ATTR_ATIME;
875 if (oa->o_valid & OBD_MD_FLMTIME) {
876 rec->sa_mtime = oa->o_mtime;
877 rec->sa_valid |= MDS_ATTR_MTIME;
879 if (oa->o_valid & OBD_MD_FLCTIME) {
880 rec->sa_ctime = oa->o_ctime;
881 rec->sa_valid |= MDS_ATTR_CTIME;
883 if (oa->o_valid & OBD_MD_FLSIZE) {
884 rec->sa_size = oa->o_size;
885 rec->sa_valid |= MDS_ATTR_SIZE;
887 if (oa->o_valid & OBD_MD_FLBLOCKS) {
888 rec->sa_blocks = oa->o_blocks;
889 rec->sa_valid |= MDS_ATTR_BLOCKS;
891 if (oa->o_valid & OBD_MD_FLFLAGS) {
892 rec->sa_attr_flags = oa->o_flags;
893 rec->sa_valid |= MDS_ATTR_ATTR_FLAG;
896 epoch->handle = och->och_fh;
904 void mdc_close_pack(struct ptlrpc_request *req, int offset,
905 struct mdc_op_data *data,
906 struct obdo *oa, __u64 valid,
907 struct obd_client_handle *och)
909 if (mdc_req_is_2_0_server(req))
910 mdc_close_pack_20(req, offset, data, oa, valid, och);
912 mdc_close_pack_18(req, offset, data, oa, valid, och);
914 struct mdc_cache_waiter {
915 struct list_head mcw_entry;
916 wait_queue_head_t mcw_waitq;
919 static int mdc_req_avail(struct client_obd *cli, struct mdc_cache_waiter *mcw)
923 spin_lock(&cli->cl_loi_list_lock);
924 rc = list_empty(&mcw->mcw_entry);
925 spin_unlock(&cli->cl_loi_list_lock);
929 /* We record requests in flight in cli->cl_r_in_flight here.
930 * There is only one write rpc possible in mdc anyway. If this to change
931 * in the future - the code may need to be revisited. */
932 void mdc_enter_request(struct client_obd *cli)
934 struct mdc_cache_waiter mcw;
935 struct l_wait_info lwi = { 0 };
937 spin_lock(&cli->cl_loi_list_lock);
938 if (cli->cl_r_in_flight >= cli->cl_max_rpcs_in_flight) {
939 list_add_tail(&mcw.mcw_entry, &cli->cl_cache_waiters);
940 init_waitqueue_head(&mcw.mcw_waitq);
941 spin_unlock(&cli->cl_loi_list_lock);
942 l_wait_event(mcw.mcw_waitq, mdc_req_avail(cli, &mcw), &lwi);
944 cli->cl_r_in_flight++;
945 spin_unlock(&cli->cl_loi_list_lock);
949 void mdc_exit_request(struct client_obd *cli)
951 struct list_head *l, *tmp;
952 struct mdc_cache_waiter *mcw;
954 spin_lock(&cli->cl_loi_list_lock);
955 cli->cl_r_in_flight--;
957 list_for_each_safe(l, tmp, &cli->cl_cache_waiters) {
958 if (cli->cl_r_in_flight >= cli->cl_max_rpcs_in_flight) {
959 /* No free request slots anymore */
963 mcw = list_entry(l, struct mdc_cache_waiter, mcw_entry);
964 list_del_init(&mcw->mcw_entry);
965 cli->cl_r_in_flight++;
966 wake_up(&mcw->mcw_waitq);
968 /* Empty waiting list? Decrease reqs in-flight number */
970 spin_unlock(&cli->cl_loi_list_lock);