drivers/staging/lustre/lustre/ptlrpc/pack_generic.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.sun.com/software/products/lustre/docs/GPLv2.pdf
  19  *
  20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  21  * CA 95054 USA or visit www.sun.com if you need additional information or
  22  * have any questions.
  23  *
  24  * GPL HEADER END
  25  */
  26 /*
  27  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
  28  * Use is subject to license terms.
  29  *
  30  * Copyright (c) 2011, 2012, Intel Corporation.
  31  */
  32 /*
  33  * This file is part of Lustre, http://www.lustre.org/
  34  * Lustre is a trademark of Sun Microsystems, Inc.
  35  *
  36  * lustre/ptlrpc/pack_generic.c
  37  *
  38  * (Un)packing of OST requests
  39  *
  40  * Author: Peter J. Braam <braam@clusterfs.com>
  41  * Author: Phil Schwan <phil@clusterfs.com>
  42  * Author: Eric Barton <eeb@clusterfs.com>
  43  */
  44
  45 #define DEBUG_SUBSYSTEM S_RPC
  46
  47 #include "../../include/linux/libcfs/libcfs.h"
  48
  49 #include "../include/obd_support.h"
  50 #include "../include/obd_class.h"
  51 #include "../include/lustre_net.h"
  52 #include "../include/obd_cksum.h"
  53 #include "../include/lustre/ll_fiemap.h"
  54
  55 #include "ptlrpc_internal.h"
  56
  57 static inline int lustre_msg_hdr_size_v2(int count)
  58 {
  59         return cfs_size_round(offsetof(struct lustre_msg_v2,
  60                                        lm_buflens[count]));
  61 }
  62
  63 int lustre_msg_hdr_size(__u32 magic, int count)
  64 {
  65         switch (magic) {
  66         case LUSTRE_MSG_MAGIC_V2:
  67                 return lustre_msg_hdr_size_v2(count);
  68         default:
  69                 LASSERTF(0, "incorrect message magic: %08x\n", magic);
  70                 return -EINVAL;
  71         }
  72 }
  73 EXPORT_SYMBOL(lustre_msg_hdr_size);
  74
  75 void ptlrpc_buf_set_swabbed(struct ptlrpc_request *req, const int inout,
  76                             int index)
  77 {
  78         if (inout)
  79                 lustre_set_req_swabbed(req, index);
  80         else
  81                 lustre_set_rep_swabbed(req, index);
  82 }
  83 EXPORT_SYMBOL(ptlrpc_buf_set_swabbed);
  84
  85 int ptlrpc_buf_need_swab(struct ptlrpc_request *req, const int inout,
  86                          int index)
  87 {
  88         if (inout)
  89                 return (ptlrpc_req_need_swab(req) &&
  90                         !lustre_req_swabbed(req, index));
  91         else
  92                 return (ptlrpc_rep_need_swab(req) &&
  93                         !lustre_rep_swabbed(req, index));
  94 }
  95 EXPORT_SYMBOL(ptlrpc_buf_need_swab);
  96
  97 static inline int lustre_msg_check_version_v2(struct lustre_msg_v2 *msg,
  98                                               __u32 version)
  99 {
 100         __u32 ver = lustre_msg_get_version(msg);
 101         return (ver & LUSTRE_VERSION_MASK) != version;
 102 }
 103
 104 int lustre_msg_check_version(struct lustre_msg *msg, __u32 version)
 105 {
 106         switch (msg->lm_magic) {
 107         case LUSTRE_MSG_MAGIC_V1:
 108                 CERROR("msg v1 not supported - please upgrade you system\n");
 109                 return -EINVAL;
 110         case LUSTRE_MSG_MAGIC_V2:
 111                 return lustre_msg_check_version_v2(msg, version);
 112         default:
 113                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
 114                 return 0;
 115         }
 116 }
 117 EXPORT_SYMBOL(lustre_msg_check_version);
 118
 119 /* early reply size */
 120 int lustre_msg_early_size(void)
 121 {
 122         static int size;
 123         if (!size) {
 124                 /* Always reply old ptlrpc_body_v2 to keep interoperability
 125                  * with the old client (< 2.3) which doesn't have pb_jobid
 126                  * in the ptlrpc_body.
 127                  *
 128                  * XXX Remove this whenever we drop interoperability with such
 129                  *     client.
 130                  */
 131                 __u32 pblen = sizeof(struct ptlrpc_body_v2);
 132                 size = lustre_msg_size(LUSTRE_MSG_MAGIC_V2, 1, &pblen);
 133         }
 134         return size;
 135 }
 136 EXPORT_SYMBOL(lustre_msg_early_size);
 137
 138 int lustre_msg_size_v2(int count, __u32 *lengths)
 139 {
 140         int size;
 141         int i;
 142
 143         size = lustre_msg_hdr_size_v2(count);
 144         for (i = 0; i < count; i++)
 145                 size += cfs_size_round(lengths[i]);
 146
 147         return size;
 148 }
 149 EXPORT_SYMBOL(lustre_msg_size_v2);
 150
 151 /* This returns the size of the buffer that is required to hold a lustre_msg
 152  * with the given sub-buffer lengths.
 153  * NOTE: this should only be used for NEW requests, and should always be
 154  *       in the form of a v2 request.  If this is a connection to a v1
 155  *       target then the first buffer will be stripped because the ptlrpc
 156  *       data is part of the lustre_msg_v1 header. b=14043 */
 157 int lustre_msg_size(__u32 magic, int count, __u32 *lens)
 158 {
 159         __u32 size[] = { sizeof(struct ptlrpc_body) };
 160
 161         if (!lens) {
 162                 LASSERT(count == 1);
 163                 lens = size;
 164         }
 165
 166         LASSERT(count > 0);
 167         LASSERT(lens[MSG_PTLRPC_BODY_OFF] >= sizeof(struct ptlrpc_body_v2));
 168
 169         switch (magic) {
 170         case LUSTRE_MSG_MAGIC_V2:
 171                 return lustre_msg_size_v2(count, lens);
 172         default:
 173                 LASSERTF(0, "incorrect message magic: %08x\n", magic);
 174                 return -EINVAL;
 175         }
 176 }
 177 EXPORT_SYMBOL(lustre_msg_size);
 178
 179 /* This is used to determine the size of a buffer that was already packed
 180  * and will correctly handle the different message formats. */
 181 int lustre_packed_msg_size(struct lustre_msg *msg)
 182 {
 183         switch (msg->lm_magic) {
 184         case LUSTRE_MSG_MAGIC_V2:
 185                 return lustre_msg_size_v2(msg->lm_bufcount, msg->lm_buflens);
 186         default:
 187                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
 188                 return 0;
 189         }
 190 }
 191 EXPORT_SYMBOL(lustre_packed_msg_size);
 192
 193 void lustre_init_msg_v2(struct lustre_msg_v2 *msg, int count, __u32 *lens,
 194                         char **bufs)
 195 {
 196         char *ptr;
 197         int i;
 198
 199         msg->lm_bufcount = count;
 200         /* XXX: lm_secflvr uninitialized here */
 201         msg->lm_magic = LUSTRE_MSG_MAGIC_V2;
 202
 203         for (i = 0; i < count; i++)
 204                 msg->lm_buflens[i] = lens[i];
 205
 206         if (bufs == NULL)
 207                 return;
 208
 209         ptr = (char *)msg + lustre_msg_hdr_size_v2(count);
 210         for (i = 0; i < count; i++) {
 211                 char *tmp = bufs[i];
 212                 LOGL(tmp, lens[i], ptr);
 213         }
 214 }
 215 EXPORT_SYMBOL(lustre_init_msg_v2);
 216
 217 static int lustre_pack_request_v2(struct ptlrpc_request *req,
 218                                   int count, __u32 *lens, char **bufs)
 219 {
 220         int reqlen, rc;
 221
 222         reqlen = lustre_msg_size_v2(count, lens);
 223
 224         rc = sptlrpc_cli_alloc_reqbuf(req, reqlen);
 225         if (rc)
 226                 return rc;
 227
 228         req->rq_reqlen = reqlen;
 229
 230         lustre_init_msg_v2(req->rq_reqmsg, count, lens, bufs);
 231         lustre_msg_add_version(req->rq_reqmsg, PTLRPC_MSG_VERSION);
 232         return 0;
 233 }
 234
 235 int lustre_pack_request(struct ptlrpc_request *req, __u32 magic, int count,
 236                         __u32 *lens, char **bufs)
 237 {
 238         __u32 size[] = { sizeof(struct ptlrpc_body) };
 239
 240         if (!lens) {
 241                 LASSERT(count == 1);
 242                 lens = size;
 243         }
 244
 245         LASSERT(count > 0);
 246         LASSERT(lens[MSG_PTLRPC_BODY_OFF] == sizeof(struct ptlrpc_body));
 247
 248         /* only use new format, we don't need to be compatible with 1.4 */
 249         return lustre_pack_request_v2(req, count, lens, bufs);
 250 }
 251 EXPORT_SYMBOL(lustre_pack_request);
 252
 253 #if RS_DEBUG
 254 LIST_HEAD(ptlrpc_rs_debug_lru);
 255 spinlock_t ptlrpc_rs_debug_lock;
 256
 257 #define PTLRPC_RS_DEBUG_LRU_ADD(rs)                                     \
 258 do {                                                                    \
 259         spin_lock(&ptlrpc_rs_debug_lock);                               \
 260         list_add_tail(&(rs)->rs_debug_list, &ptlrpc_rs_debug_lru);      \
 261         spin_unlock(&ptlrpc_rs_debug_lock);                             \
 262 } while (0)
 263
 264 #define PTLRPC_RS_DEBUG_LRU_DEL(rs)                                     \
 265 do {                                                                    \
 266         spin_lock(&ptlrpc_rs_debug_lock);                               \
 267         list_del(&(rs)->rs_debug_list);                         \
 268         spin_unlock(&ptlrpc_rs_debug_lock);                             \
 269 } while (0)
 270 #else
 271 # define PTLRPC_RS_DEBUG_LRU_ADD(rs) do {} while (0)
 272 # define PTLRPC_RS_DEBUG_LRU_DEL(rs) do {} while (0)
 273 #endif
 274
 275 struct ptlrpc_reply_state *
 276 lustre_get_emerg_rs(struct ptlrpc_service_part *svcpt)
 277 {
 278         struct ptlrpc_reply_state *rs = NULL;
 279
 280         spin_lock(&svcpt->scp_rep_lock);
 281
 282         /* See if we have anything in a pool, and wait if nothing */
 283         while (list_empty(&svcpt->scp_rep_idle)) {
 284                 struct l_wait_info lwi;
 285                 int rc;
 286
 287                 spin_unlock(&svcpt->scp_rep_lock);
 288                 /* If we cannot get anything for some long time, we better
 289                  * bail out instead of waiting infinitely */
 290                 lwi = LWI_TIMEOUT(cfs_time_seconds(10), NULL, NULL);
 291                 rc = l_wait_event(svcpt->scp_rep_waitq,
 292                                   !list_empty(&svcpt->scp_rep_idle), &lwi);
 293                 if (rc != 0)
 294                         goto out;
 295                 spin_lock(&svcpt->scp_rep_lock);
 296         }
 297
 298         rs = list_entry(svcpt->scp_rep_idle.next,
 299                             struct ptlrpc_reply_state, rs_list);
 300         list_del(&rs->rs_list);
 301
 302         spin_unlock(&svcpt->scp_rep_lock);
 303
 304         memset(rs, 0, svcpt->scp_service->srv_max_reply_size);
 305         rs->rs_size = svcpt->scp_service->srv_max_reply_size;
 306         rs->rs_svcpt = svcpt;
 307         rs->rs_prealloc = 1;
 308 out:
 309         return rs;
 310 }
 311
 312 void lustre_put_emerg_rs(struct ptlrpc_reply_state *rs)
 313 {
 314         struct ptlrpc_service_part *svcpt = rs->rs_svcpt;
 315
 316         spin_lock(&svcpt->scp_rep_lock);
 317         list_add(&rs->rs_list, &svcpt->scp_rep_idle);
 318         spin_unlock(&svcpt->scp_rep_lock);
 319         wake_up(&svcpt->scp_rep_waitq);
 320 }
 321
 322 int lustre_pack_reply_v2(struct ptlrpc_request *req, int count,
 323                          __u32 *lens, char **bufs, int flags)
 324 {
 325         struct ptlrpc_reply_state *rs;
 326         int msg_len, rc;
 327
 328         LASSERT(req->rq_reply_state == NULL);
 329
 330         if ((flags & LPRFL_EARLY_REPLY) == 0) {
 331                 spin_lock(&req->rq_lock);
 332                 req->rq_packed_final = 1;
 333                 spin_unlock(&req->rq_lock);
 334         }
 335
 336         msg_len = lustre_msg_size_v2(count, lens);
 337         rc = sptlrpc_svc_alloc_rs(req, msg_len);
 338         if (rc)
 339                 return rc;
 340
 341         rs = req->rq_reply_state;
 342         atomic_set(&rs->rs_refcount, 1);    /* 1 ref for rq_reply_state */
 343         rs->rs_cb_id.cbid_fn = reply_out_callback;
 344         rs->rs_cb_id.cbid_arg = rs;
 345         rs->rs_svcpt = req->rq_rqbd->rqbd_svcpt;
 346         INIT_LIST_HEAD(&rs->rs_exp_list);
 347         INIT_LIST_HEAD(&rs->rs_obd_list);
 348         INIT_LIST_HEAD(&rs->rs_list);
 349         spin_lock_init(&rs->rs_lock);
 350
 351         req->rq_replen = msg_len;
 352         req->rq_reply_state = rs;
 353         req->rq_repmsg = rs->rs_msg;
 354
 355         lustre_init_msg_v2(rs->rs_msg, count, lens, bufs);
 356         lustre_msg_add_version(rs->rs_msg, PTLRPC_MSG_VERSION);
 357
 358         PTLRPC_RS_DEBUG_LRU_ADD(rs);
 359
 360         return 0;
 361 }
 362 EXPORT_SYMBOL(lustre_pack_reply_v2);
 363
 364 int lustre_pack_reply_flags(struct ptlrpc_request *req, int count, __u32 *lens,
 365                             char **bufs, int flags)
 366 {
 367         int rc = 0;
 368         __u32 size[] = { sizeof(struct ptlrpc_body) };
 369
 370         if (!lens) {
 371                 LASSERT(count == 1);
 372                 lens = size;
 373         }
 374
 375         LASSERT(count > 0);
 376         LASSERT(lens[MSG_PTLRPC_BODY_OFF] == sizeof(struct ptlrpc_body));
 377
 378         switch (req->rq_reqmsg->lm_magic) {
 379         case LUSTRE_MSG_MAGIC_V2:
 380                 rc = lustre_pack_reply_v2(req, count, lens, bufs, flags);
 381                 break;
 382         default:
 383                 LASSERTF(0, "incorrect message magic: %08x\n",
 384                          req->rq_reqmsg->lm_magic);
 385                 rc = -EINVAL;
 386         }
 387         if (rc != 0)
 388                 CERROR("lustre_pack_reply failed: rc=%d size=%d\n", rc,
 389                        lustre_msg_size(req->rq_reqmsg->lm_magic, count, lens));
 390         return rc;
 391 }
 392 EXPORT_SYMBOL(lustre_pack_reply_flags);
 393
 394 int lustre_pack_reply(struct ptlrpc_request *req, int count, __u32 *lens,
 395                       char **bufs)
 396 {
 397         return lustre_pack_reply_flags(req, count, lens, bufs, 0);
 398 }
 399 EXPORT_SYMBOL(lustre_pack_reply);
 400
 401 void *lustre_msg_buf_v2(struct lustre_msg_v2 *m, int n, int min_size)
 402 {
 403         int i, offset, buflen, bufcount;
 404
 405         LASSERT(m != NULL);
 406         LASSERT(n >= 0);
 407
 408         bufcount = m->lm_bufcount;
 409         if (unlikely(n >= bufcount)) {
 410                 CDEBUG(D_INFO, "msg %p buffer[%d] not present (count %d)\n",
 411                        m, n, bufcount);
 412                 return NULL;
 413         }
 414
 415         buflen = m->lm_buflens[n];
 416         if (unlikely(buflen < min_size)) {
 417                 CERROR("msg %p buffer[%d] size %d too small (required %d, opc=%d)\n",
 418                        m, n, buflen, min_size,
 419                        n == MSG_PTLRPC_BODY_OFF ? -1 : lustre_msg_get_opc(m));
 420                 return NULL;
 421         }
 422
 423         offset = lustre_msg_hdr_size_v2(bufcount);
 424         for (i = 0; i < n; i++)
 425                 offset += cfs_size_round(m->lm_buflens[i]);
 426
 427         return (char *)m + offset;
 428 }
 429
 430 void *lustre_msg_buf(struct lustre_msg *m, int n, int min_size)
 431 {
 432         switch (m->lm_magic) {
 433         case LUSTRE_MSG_MAGIC_V2:
 434                 return lustre_msg_buf_v2(m, n, min_size);
 435         default:
 436                 LASSERTF(0, "incorrect message magic: %08x(msg:%p)\n", m->lm_magic, m);
 437                 return NULL;
 438         }
 439 }
 440 EXPORT_SYMBOL(lustre_msg_buf);
 441
 442 int lustre_shrink_msg_v2(struct lustre_msg_v2 *msg, int segment,
 443                          unsigned int newlen, int move_data)
 444 {
 445         char *tail = NULL, *newpos;
 446         int tail_len = 0, n;
 447
 448         LASSERT(msg);
 449         LASSERT(msg->lm_bufcount > segment);
 450         LASSERT(msg->lm_buflens[segment] >= newlen);
 451
 452         if (msg->lm_buflens[segment] == newlen)
 453                 goto out;
 454
 455         if (move_data && msg->lm_bufcount > segment + 1) {
 456                 tail = lustre_msg_buf_v2(msg, segment + 1, 0);
 457                 for (n = segment + 1; n < msg->lm_bufcount; n++)
 458                         tail_len += cfs_size_round(msg->lm_buflens[n]);
 459         }
 460
 461         msg->lm_buflens[segment] = newlen;
 462
 463         if (tail && tail_len) {
 464                 newpos = lustre_msg_buf_v2(msg, segment + 1, 0);
 465                 LASSERT(newpos <= tail);
 466                 if (newpos != tail)
 467                         memmove(newpos, tail, tail_len);
 468         }
 469 out:
 470         return lustre_msg_size_v2(msg->lm_bufcount, msg->lm_buflens);
 471 }
 472
 473 /*
 474  * for @msg, shrink @segment to size @newlen. if @move_data is non-zero,
 475  * we also move data forward from @segment + 1.
 476  *
 477  * if @newlen == 0, we remove the segment completely, but we still keep the
 478  * totally bufcount the same to save possible data moving. this will leave a
 479  * unused segment with size 0 at the tail, but that's ok.
 480  *
 481  * return new msg size after shrinking.
 482  *
 483  * CAUTION:
 484  * + if any buffers higher than @segment has been filled in, must call shrink
 485  *   with non-zero @move_data.
 486  * + caller should NOT keep pointers to msg buffers which higher than @segment
 487  *   after call shrink.
 488  */
 489 int lustre_shrink_msg(struct lustre_msg *msg, int segment,
 490                       unsigned int newlen, int move_data)
 491 {
 492         switch (msg->lm_magic) {
 493         case LUSTRE_MSG_MAGIC_V2:
 494                 return lustre_shrink_msg_v2(msg, segment, newlen, move_data);
 495         default:
 496                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
 497         }
 498 }
 499 EXPORT_SYMBOL(lustre_shrink_msg);
 500
 501 void lustre_free_reply_state(struct ptlrpc_reply_state *rs)
 502 {
 503         PTLRPC_RS_DEBUG_LRU_DEL(rs);
 504
 505         LASSERT(atomic_read(&rs->rs_refcount) == 0);
 506         LASSERT(!rs->rs_difficult || rs->rs_handled);
 507         LASSERT(!rs->rs_on_net);
 508         LASSERT(!rs->rs_scheduled);
 509         LASSERT(rs->rs_export == NULL);
 510         LASSERT(rs->rs_nlocks == 0);
 511         LASSERT(list_empty(&rs->rs_exp_list));
 512         LASSERT(list_empty(&rs->rs_obd_list));
 513
 514         sptlrpc_svc_free_rs(rs);
 515 }
 516 EXPORT_SYMBOL(lustre_free_reply_state);
 517
 518 static int lustre_unpack_msg_v2(struct lustre_msg_v2 *m, int len)
 519 {
 520         int swabbed, required_len, i;
 521
 522         /* Now we know the sender speaks my language. */
 523         required_len = lustre_msg_hdr_size_v2(0);
 524         if (len < required_len) {
 525                 /* can't even look inside the message */
 526                 CERROR("message length %d too small for lustre_msg\n", len);
 527                 return -EINVAL;
 528         }
 529
 530         swabbed = (m->lm_magic == LUSTRE_MSG_MAGIC_V2_SWABBED);
 531
 532         if (swabbed) {
 533                 __swab32s(&m->lm_magic);
 534                 __swab32s(&m->lm_bufcount);
 535                 __swab32s(&m->lm_secflvr);
 536                 __swab32s(&m->lm_repsize);
 537                 __swab32s(&m->lm_cksum);
 538                 __swab32s(&m->lm_flags);
 539                 CLASSERT(offsetof(typeof(*m), lm_padding_2) != 0);
 540                 CLASSERT(offsetof(typeof(*m), lm_padding_3) != 0);
 541         }
 542
 543         required_len = lustre_msg_hdr_size_v2(m->lm_bufcount);
 544         if (len < required_len) {
 545                 /* didn't receive all the buffer lengths */
 546                 CERROR("message length %d too small for %d buflens\n",
 547                        len, m->lm_bufcount);
 548                 return -EINVAL;
 549         }
 550
 551         for (i = 0; i < m->lm_bufcount; i++) {
 552                 if (swabbed)
 553                         __swab32s(&m->lm_buflens[i]);
 554                 required_len += cfs_size_round(m->lm_buflens[i]);
 555         }
 556
 557         if (len < required_len) {
 558                 CERROR("len: %d, required_len %d\n", len, required_len);
 559                 CERROR("bufcount: %d\n", m->lm_bufcount);
 560                 for (i = 0; i < m->lm_bufcount; i++)
 561                         CERROR("buffer %d length %d\n", i, m->lm_buflens[i]);
 562                 return -EINVAL;
 563         }
 564
 565         return swabbed;
 566 }
 567
 568 int __lustre_unpack_msg(struct lustre_msg *m, int len)
 569 {
 570         int required_len, rc;
 571
 572         /* We can provide a slightly better error log, if we check the
 573          * message magic and version first.  In the future, struct
 574          * lustre_msg may grow, and we'd like to log a version mismatch,
 575          * rather than a short message.
 576          *
 577          */
 578         required_len = offsetof(struct lustre_msg, lm_magic) +
 579                        sizeof(m->lm_magic);
 580         if (len < required_len) {
 581                 /* can't even look inside the message */
 582                 CERROR("message length %d too small for magic/version check\n",
 583                        len);
 584                 return -EINVAL;
 585         }
 586
 587         rc = lustre_unpack_msg_v2(m, len);
 588
 589         return rc;
 590 }
 591 EXPORT_SYMBOL(__lustre_unpack_msg);
 592
 593 int ptlrpc_unpack_req_msg(struct ptlrpc_request *req, int len)
 594 {
 595         int rc;
 596         rc = __lustre_unpack_msg(req->rq_reqmsg, len);
 597         if (rc == 1) {
 598                 lustre_set_req_swabbed(req, MSG_PTLRPC_HEADER_OFF);
 599                 rc = 0;
 600         }
 601         return rc;
 602 }
 603 EXPORT_SYMBOL(ptlrpc_unpack_req_msg);
 604
 605 int ptlrpc_unpack_rep_msg(struct ptlrpc_request *req, int len)
 606 {
 607         int rc;
 608         rc = __lustre_unpack_msg(req->rq_repmsg, len);
 609         if (rc == 1) {
 610                 lustre_set_rep_swabbed(req, MSG_PTLRPC_HEADER_OFF);
 611                 rc = 0;
 612         }
 613         return rc;
 614 }
 615 EXPORT_SYMBOL(ptlrpc_unpack_rep_msg);
 616
 617 static inline int lustre_unpack_ptlrpc_body_v2(struct ptlrpc_request *req,
 618                                                const int inout, int offset)
 619 {
 620         struct ptlrpc_body *pb;
 621         struct lustre_msg_v2 *m = inout ? req->rq_reqmsg : req->rq_repmsg;
 622
 623         pb = lustre_msg_buf_v2(m, offset, sizeof(struct ptlrpc_body_v2));
 624         if (!pb) {
 625                 CERROR("error unpacking ptlrpc body\n");
 626                 return -EFAULT;
 627         }
 628         if (ptlrpc_buf_need_swab(req, inout, offset)) {
 629                 lustre_swab_ptlrpc_body(pb);
 630                 ptlrpc_buf_set_swabbed(req, inout, offset);
 631         }
 632
 633         if ((pb->pb_version & ~LUSTRE_VERSION_MASK) != PTLRPC_MSG_VERSION) {
 634                 CERROR("wrong lustre_msg version %08x\n", pb->pb_version);
 635                 return -EINVAL;
 636         }
 637
 638         if (!inout)
 639                 pb->pb_status = ptlrpc_status_ntoh(pb->pb_status);
 640
 641         return 0;
 642 }
 643
 644 int lustre_unpack_req_ptlrpc_body(struct ptlrpc_request *req, int offset)
 645 {
 646         switch (req->rq_reqmsg->lm_magic) {
 647         case LUSTRE_MSG_MAGIC_V2:
 648                 return lustre_unpack_ptlrpc_body_v2(req, 1, offset);
 649         default:
 650                 CERROR("bad lustre msg magic: %08x\n",
 651                        req->rq_reqmsg->lm_magic);
 652                 return -EINVAL;
 653         }
 654 }
 655
 656 int lustre_unpack_rep_ptlrpc_body(struct ptlrpc_request *req, int offset)
 657 {
 658         switch (req->rq_repmsg->lm_magic) {
 659         case LUSTRE_MSG_MAGIC_V2:
 660                 return lustre_unpack_ptlrpc_body_v2(req, 0, offset);
 661         default:
 662                 CERROR("bad lustre msg magic: %08x\n",
 663                        req->rq_repmsg->lm_magic);
 664                 return -EINVAL;
 665         }
 666 }
 667
 668 static inline int lustre_msg_buflen_v2(struct lustre_msg_v2 *m, int n)
 669 {
 670         if (n >= m->lm_bufcount)
 671                 return 0;
 672
 673         return m->lm_buflens[n];
 674 }
 675
 676 /**
 677  * lustre_msg_buflen - return the length of buffer \a n in message \a m
 678  * \param m lustre_msg (request or reply) to look at
 679  * \param n message index (base 0)
 680  *
 681  * returns zero for non-existent message indices
 682  */
 683 int lustre_msg_buflen(struct lustre_msg *m, int n)
 684 {
 685         switch (m->lm_magic) {
 686         case LUSTRE_MSG_MAGIC_V2:
 687                 return lustre_msg_buflen_v2(m, n);
 688         default:
 689                 CERROR("incorrect message magic: %08x\n", m->lm_magic);
 690                 return -EINVAL;
 691         }
 692 }
 693 EXPORT_SYMBOL(lustre_msg_buflen);
 694
 695 static inline void
 696 lustre_msg_set_buflen_v2(struct lustre_msg_v2 *m, int n, int len)
 697 {
 698         if (n >= m->lm_bufcount)
 699                 LBUG();
 700
 701         m->lm_buflens[n] = len;
 702 }
 703
 704 void lustre_msg_set_buflen(struct lustre_msg *m, int n, int len)
 705 {
 706         switch (m->lm_magic) {
 707         case LUSTRE_MSG_MAGIC_V2:
 708                 lustre_msg_set_buflen_v2(m, n, len);
 709                 return;
 710         default:
 711                 LASSERTF(0, "incorrect message magic: %08x\n", m->lm_magic);
 712         }
 713 }
 714
 715 EXPORT_SYMBOL(lustre_msg_set_buflen);
 716
 717 /* NB return the bufcount for lustre_msg_v2 format, so if message is packed
 718  * in V1 format, the result is one bigger. (add struct ptlrpc_body). */
 719 int lustre_msg_bufcount(struct lustre_msg *m)
 720 {
 721         switch (m->lm_magic) {
 722         case LUSTRE_MSG_MAGIC_V2:
 723                 return m->lm_bufcount;
 724         default:
 725                 CERROR("incorrect message magic: %08x\n", m->lm_magic);
 726                 return -EINVAL;
 727         }
 728 }
 729 EXPORT_SYMBOL(lustre_msg_bufcount);
 730
 731 char *lustre_msg_string(struct lustre_msg *m, int index, int max_len)
 732 {
 733         /* max_len == 0 means the string should fill the buffer */
 734         char *str;
 735         int slen, blen;
 736
 737         switch (m->lm_magic) {
 738         case LUSTRE_MSG_MAGIC_V2:
 739                 str = lustre_msg_buf_v2(m, index, 0);
 740                 blen = lustre_msg_buflen_v2(m, index);
 741                 break;
 742         default:
 743                 LASSERTF(0, "incorrect message magic: %08x\n", m->lm_magic);
 744         }
 745
 746         if (str == NULL) {
 747                 CERROR("can't unpack string in msg %p buffer[%d]\n", m, index);
 748                 return NULL;
 749         }
 750
 751         slen = strnlen(str, blen);
 752
 753         if (slen == blen) {                  /* not NULL terminated */
 754                 CERROR("can't unpack non-NULL terminated string in msg %p buffer[%d] len %d\n",
 755                        m, index, blen);
 756                 return NULL;
 757         }
 758
 759         if (max_len == 0) {
 760                 if (slen != blen - 1) {
 761                         CERROR("can't unpack short string in msg %p buffer[%d] len %d: strlen %d\n",
 762                                m, index, blen, slen);
 763                         return NULL;
 764                 }
 765         } else if (slen > max_len) {
 766                 CERROR("can't unpack oversized string in msg %p buffer[%d] len %d strlen %d: max %d expected\n",
 767                        m, index, blen, slen, max_len);
 768                 return NULL;
 769         }
 770
 771         return str;
 772 }
 773 EXPORT_SYMBOL(lustre_msg_string);
 774
 775 /* Wrap up the normal fixed length cases */
 776 static inline void *__lustre_swab_buf(struct lustre_msg *msg, int index,
 777                                       int min_size, void *swabber)
 778 {
 779         void *ptr = NULL;
 780
 781         LASSERT(msg != NULL);
 782         switch (msg->lm_magic) {
 783         case LUSTRE_MSG_MAGIC_V2:
 784                 ptr = lustre_msg_buf_v2(msg, index, min_size);
 785                 break;
 786         default:
 787                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
 788         }
 789
 790         if (ptr && swabber)
 791                 ((void (*)(void *))swabber)(ptr);
 792
 793         return ptr;
 794 }
 795
 796 static inline struct ptlrpc_body *lustre_msg_ptlrpc_body(struct lustre_msg *msg)
 797 {
 798         return lustre_msg_buf_v2(msg, MSG_PTLRPC_BODY_OFF,
 799                                  sizeof(struct ptlrpc_body_v2));
 800 }
 801
 802 __u32 lustre_msghdr_get_flags(struct lustre_msg *msg)
 803 {
 804         switch (msg->lm_magic) {
 805         case LUSTRE_MSG_MAGIC_V1:
 806         case LUSTRE_MSG_MAGIC_V1_SWABBED:
 807                 return 0;
 808         case LUSTRE_MSG_MAGIC_V2:
 809                 /* already in host endian */
 810                 return msg->lm_flags;
 811         default:
 812                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
 813                 return 0;
 814         }
 815 }
 816 EXPORT_SYMBOL(lustre_msghdr_get_flags);
 817
 818 void lustre_msghdr_set_flags(struct lustre_msg *msg, __u32 flags)
 819 {
 820         switch (msg->lm_magic) {
 821         case LUSTRE_MSG_MAGIC_V1:
 822                 return;
 823         case LUSTRE_MSG_MAGIC_V2:
 824                 msg->lm_flags = flags;
 825                 return;
 826         default:
 827                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
 828         }
 829 }
 830
 831 __u32 lustre_msg_get_flags(struct lustre_msg *msg)
 832 {
 833         switch (msg->lm_magic) {
 834         case LUSTRE_MSG_MAGIC_V2: {
 835                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
 836                 if (!pb) {
 837                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
 838                         return 0;
 839                 }
 840                 return pb->pb_flags;
 841         }
 842         default:
 843                 /* flags might be printed in debug code while message
 844                  * uninitialized */
 845                 return 0;
 846         }
 847 }
 848 EXPORT_SYMBOL(lustre_msg_get_flags);
 849
 850 void lustre_msg_add_flags(struct lustre_msg *msg, int flags)
 851 {
 852         switch (msg->lm_magic) {
 853         case LUSTRE_MSG_MAGIC_V2: {
 854                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
 855                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
 856                 pb->pb_flags |= flags;
 857                 return;
 858         }
 859         default:
 860                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
 861         }
 862 }
 863 EXPORT_SYMBOL(lustre_msg_add_flags);
 864
 865 void lustre_msg_set_flags(struct lustre_msg *msg, int flags)
 866 {
 867         switch (msg->lm_magic) {
 868         case LUSTRE_MSG_MAGIC_V2: {
 869                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
 870                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
 871                 pb->pb_flags = flags;
 872                 return;
 873         }
 874         default:
 875                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
 876         }
 877 }
 878 EXPORT_SYMBOL(lustre_msg_set_flags);
 879
 880 void lustre_msg_clear_flags(struct lustre_msg *msg, int flags)
 881 {
 882         switch (msg->lm_magic) {
 883         case LUSTRE_MSG_MAGIC_V2: {
 884                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
 885                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
 886                 pb->pb_flags &= ~(MSG_GEN_FLAG_MASK & flags);
 887                 return;
 888         }
 889         default:
 890                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
 891         }
 892 }
 893 EXPORT_SYMBOL(lustre_msg_clear_flags);
 894
 895 __u32 lustre_msg_get_op_flags(struct lustre_msg *msg)
 896 {
 897         switch (msg->lm_magic) {
 898         case LUSTRE_MSG_MAGIC_V2: {
 899                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
 900                 if (!pb) {
 901                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
 902                         return 0;
 903                 }
 904                 return pb->pb_op_flags;
 905         }
 906         default:
 907                 return 0;
 908         }
 909 }
 910 EXPORT_SYMBOL(lustre_msg_get_op_flags);
 911
 912 void lustre_msg_add_op_flags(struct lustre_msg *msg, int flags)
 913 {
 914         switch (msg->lm_magic) {
 915         case LUSTRE_MSG_MAGIC_V2: {
 916                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
 917                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
 918                 pb->pb_op_flags |= flags;
 919                 return;
 920         }
 921         default:
 922                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
 923         }
 924 }
 925 EXPORT_SYMBOL(lustre_msg_add_op_flags);
 926
 927 void lustre_msg_set_op_flags(struct lustre_msg *msg, int flags)
 928 {
 929         switch (msg->lm_magic) {
 930         case LUSTRE_MSG_MAGIC_V2: {
 931                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
 932                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
 933                 pb->pb_op_flags |= flags;
 934                 return;
 935         }
 936         default:
 937                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
 938         }
 939 }
 940 EXPORT_SYMBOL(lustre_msg_set_op_flags);
 941
 942 struct lustre_handle *lustre_msg_get_handle(struct lustre_msg *msg)
 943 {
 944         switch (msg->lm_magic) {
 945         case LUSTRE_MSG_MAGIC_V2: {
 946                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
 947                 if (!pb) {
 948                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
 949                         return NULL;
 950                 }
 951                 return &pb->pb_handle;
 952         }
 953         default:
 954                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
 955                 return NULL;
 956         }
 957 }
 958 EXPORT_SYMBOL(lustre_msg_get_handle);
 959
 960 __u32 lustre_msg_get_type(struct lustre_msg *msg)
 961 {
 962         switch (msg->lm_magic) {
 963         case LUSTRE_MSG_MAGIC_V2: {
 964                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
 965                 if (!pb) {
 966                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
 967                         return PTL_RPC_MSG_ERR;
 968                 }
 969                 return pb->pb_type;
 970         }
 971         default:
 972                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
 973                 return PTL_RPC_MSG_ERR;
 974         }
 975 }
 976 EXPORT_SYMBOL(lustre_msg_get_type);
 977
 978 __u32 lustre_msg_get_version(struct lustre_msg *msg)
 979 {
 980         switch (msg->lm_magic) {
 981         case LUSTRE_MSG_MAGIC_V2: {
 982                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
 983                 if (!pb) {
 984                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
 985                         return 0;
 986                 }
 987                 return pb->pb_version;
 988         }
 989         default:
 990                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
 991                 return 0;
 992         }
 993 }
 994 EXPORT_SYMBOL(lustre_msg_get_version);
 995
 996 void lustre_msg_add_version(struct lustre_msg *msg, int version)
 997 {
 998         switch (msg->lm_magic) {
 999         case LUSTRE_MSG_MAGIC_V2: {
1000                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1001                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1002                 pb->pb_version |= version;
1003                 return;
1004         }
1005         default:
1006                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1007         }
1008 }
1009 EXPORT_SYMBOL(lustre_msg_add_version);
1010
1011 __u32 lustre_msg_get_opc(struct lustre_msg *msg)
1012 {
1013         switch (msg->lm_magic) {
1014         case LUSTRE_MSG_MAGIC_V2: {
1015                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1016                 if (!pb) {
1017                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1018                         return 0;
1019                 }
1020                 return pb->pb_opc;
1021         }
1022         default:
1023                 CERROR("incorrect message magic: %08x(msg:%p)\n", msg->lm_magic, msg);
1024                 LBUG();
1025                 return 0;
1026         }
1027 }
1028 EXPORT_SYMBOL(lustre_msg_get_opc);
1029
1030 __u64 lustre_msg_get_last_xid(struct lustre_msg *msg)
1031 {
1032         switch (msg->lm_magic) {
1033         case LUSTRE_MSG_MAGIC_V2: {
1034                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1035                 if (!pb) {
1036                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1037                         return 0;
1038                 }
1039                 return pb->pb_last_xid;
1040         }
1041         default:
1042                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1043                 return 0;
1044         }
1045 }
1046 EXPORT_SYMBOL(lustre_msg_get_last_xid);
1047
1048 __u64 lustre_msg_get_last_committed(struct lustre_msg *msg)
1049 {
1050         switch (msg->lm_magic) {
1051         case LUSTRE_MSG_MAGIC_V2: {
1052                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1053                 if (!pb) {
1054                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1055                         return 0;
1056                 }
1057                 return pb->pb_last_committed;
1058         }
1059         default:
1060                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1061                 return 0;
1062         }
1063 }
1064 EXPORT_SYMBOL(lustre_msg_get_last_committed);
1065
1066 __u64 *lustre_msg_get_versions(struct lustre_msg *msg)
1067 {
1068         switch (msg->lm_magic) {
1069         case LUSTRE_MSG_MAGIC_V1:
1070                 return NULL;
1071         case LUSTRE_MSG_MAGIC_V2: {
1072                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1073                 if (!pb) {
1074                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1075                         return NULL;
1076                 }
1077                 return pb->pb_pre_versions;
1078         }
1079         default:
1080                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1081                 return NULL;
1082         }
1083 }
1084 EXPORT_SYMBOL(lustre_msg_get_versions);
1085
1086 __u64 lustre_msg_get_transno(struct lustre_msg *msg)
1087 {
1088         switch (msg->lm_magic) {
1089         case LUSTRE_MSG_MAGIC_V2: {
1090                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1091                 if (!pb) {
1092                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1093                         return 0;
1094                 }
1095                 return pb->pb_transno;
1096         }
1097         default:
1098                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1099                 return 0;
1100         }
1101 }
1102 EXPORT_SYMBOL(lustre_msg_get_transno);
1103
1104 int lustre_msg_get_status(struct lustre_msg *msg)
1105 {
1106         switch (msg->lm_magic) {
1107         case LUSTRE_MSG_MAGIC_V2: {
1108                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1109                 if (!pb) {
1110                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1111                         return -EINVAL;
1112                 }
1113                 return pb->pb_status;
1114         }
1115         default:
1116                 /* status might be printed in debug code while message
1117                  * uninitialized */
1118                 return -EINVAL;
1119         }
1120 }
1121 EXPORT_SYMBOL(lustre_msg_get_status);
1122
1123 __u64 lustre_msg_get_slv(struct lustre_msg *msg)
1124 {
1125         switch (msg->lm_magic) {
1126         case LUSTRE_MSG_MAGIC_V2: {
1127                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1128                 if (!pb) {
1129                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1130                         return -EINVAL;
1131                 }
1132                 return pb->pb_slv;
1133         }
1134         default:
1135                 CERROR("invalid msg magic %08x\n", msg->lm_magic);
1136                 return -EINVAL;
1137         }
1138 }
1139 EXPORT_SYMBOL(lustre_msg_get_slv);
1140
1141
1142 void lustre_msg_set_slv(struct lustre_msg *msg, __u64 slv)
1143 {
1144         switch (msg->lm_magic) {
1145         case LUSTRE_MSG_MAGIC_V2: {
1146                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1147                 if (!pb) {
1148                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1149                         return;
1150                 }
1151                 pb->pb_slv = slv;
1152                 return;
1153         }
1154         default:
1155                 CERROR("invalid msg magic %x\n", msg->lm_magic);
1156                 return;
1157         }
1158 }
1159 EXPORT_SYMBOL(lustre_msg_set_slv);
1160
1161 __u32 lustre_msg_get_limit(struct lustre_msg *msg)
1162 {
1163         switch (msg->lm_magic) {
1164         case LUSTRE_MSG_MAGIC_V2: {
1165                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1166                 if (!pb) {
1167                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1168                         return -EINVAL;
1169                 }
1170                 return pb->pb_limit;
1171         }
1172         default:
1173                 CERROR("invalid msg magic %x\n", msg->lm_magic);
1174                 return -EINVAL;
1175         }
1176 }
1177 EXPORT_SYMBOL(lustre_msg_get_limit);
1178
1179
1180 void lustre_msg_set_limit(struct lustre_msg *msg, __u64 limit)
1181 {
1182         switch (msg->lm_magic) {
1183         case LUSTRE_MSG_MAGIC_V2: {
1184                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1185                 if (!pb) {
1186                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1187                         return;
1188                 }
1189                 pb->pb_limit = limit;
1190                 return;
1191         }
1192         default:
1193                 CERROR("invalid msg magic %08x\n", msg->lm_magic);
1194                 return;
1195         }
1196 }
1197 EXPORT_SYMBOL(lustre_msg_set_limit);
1198
1199 __u32 lustre_msg_get_conn_cnt(struct lustre_msg *msg)
1200 {
1201         switch (msg->lm_magic) {
1202         case LUSTRE_MSG_MAGIC_V2: {
1203                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1204                 if (!pb) {
1205                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1206                         return 0;
1207                 }
1208                 return pb->pb_conn_cnt;
1209         }
1210         default:
1211                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1212                 return 0;
1213         }
1214 }
1215 EXPORT_SYMBOL(lustre_msg_get_conn_cnt);
1216
1217 int lustre_msg_is_v1(struct lustre_msg *msg)
1218 {
1219         switch (msg->lm_magic) {
1220         case LUSTRE_MSG_MAGIC_V1:
1221         case LUSTRE_MSG_MAGIC_V1_SWABBED:
1222                 return 1;
1223         default:
1224                 return 0;
1225         }
1226 }
1227 EXPORT_SYMBOL(lustre_msg_is_v1);
1228
1229 __u32 lustre_msg_get_magic(struct lustre_msg *msg)
1230 {
1231         switch (msg->lm_magic) {
1232         case LUSTRE_MSG_MAGIC_V2:
1233                 return msg->lm_magic;
1234         default:
1235                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1236                 return 0;
1237         }
1238 }
1239 EXPORT_SYMBOL(lustre_msg_get_magic);
1240
1241 __u32 lustre_msg_get_timeout(struct lustre_msg *msg)
1242 {
1243         switch (msg->lm_magic) {
1244         case LUSTRE_MSG_MAGIC_V1:
1245         case LUSTRE_MSG_MAGIC_V1_SWABBED:
1246                 return 0;
1247         case LUSTRE_MSG_MAGIC_V2: {
1248                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1249                 if (!pb) {
1250                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1251                         return 0;
1252
1253                 }
1254                 return pb->pb_timeout;
1255         }
1256         default:
1257                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1258                 return 0;
1259         }
1260 }
1261
1262 __u32 lustre_msg_get_service_time(struct lustre_msg *msg)
1263 {
1264         switch (msg->lm_magic) {
1265         case LUSTRE_MSG_MAGIC_V1:
1266         case LUSTRE_MSG_MAGIC_V1_SWABBED:
1267                 return 0;
1268         case LUSTRE_MSG_MAGIC_V2: {
1269                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1270                 if (!pb) {
1271                         CERROR("invalid msg %p: no ptlrpc body!\n", msg);
1272                         return 0;
1273
1274                 }
1275                 return pb->pb_service_time;
1276         }
1277         default:
1278                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1279                 return 0;
1280         }
1281 }
1282
1283 char *lustre_msg_get_jobid(struct lustre_msg *msg)
1284 {
1285         switch (msg->lm_magic) {
1286         case LUSTRE_MSG_MAGIC_V1:
1287         case LUSTRE_MSG_MAGIC_V1_SWABBED:
1288                 return NULL;
1289         case LUSTRE_MSG_MAGIC_V2: {
1290                 struct ptlrpc_body *pb =
1291                         lustre_msg_buf_v2(msg, MSG_PTLRPC_BODY_OFF,
1292                                           sizeof(struct ptlrpc_body));
1293                 if (!pb)
1294                         return NULL;
1295
1296                 return pb->pb_jobid;
1297         }
1298         default:
1299                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1300                 return NULL;
1301         }
1302 }
1303 EXPORT_SYMBOL(lustre_msg_get_jobid);
1304
1305 __u32 lustre_msg_get_cksum(struct lustre_msg *msg)
1306 {
1307         switch (msg->lm_magic) {
1308         case LUSTRE_MSG_MAGIC_V2:
1309                 return msg->lm_cksum;
1310         default:
1311                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1312                 return 0;
1313         }
1314 }
1315
1316 __u32 lustre_msg_calc_cksum(struct lustre_msg *msg)
1317 {
1318         switch (msg->lm_magic) {
1319         case LUSTRE_MSG_MAGIC_V2: {
1320                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1321                 __u32 crc;
1322                 unsigned int hsize = 4;
1323                 cfs_crypto_hash_digest(CFS_HASH_ALG_CRC32, (unsigned char *)pb,
1324                                    lustre_msg_buflen(msg, MSG_PTLRPC_BODY_OFF),
1325                                    NULL, 0, (unsigned char *)&crc, &hsize);
1326                 return crc;
1327         }
1328         default:
1329                 CERROR("incorrect message magic: %08x\n", msg->lm_magic);
1330                 return 0;
1331         }
1332 }
1333
1334 void lustre_msg_set_handle(struct lustre_msg *msg, struct lustre_handle *handle)
1335 {
1336         switch (msg->lm_magic) {
1337         case LUSTRE_MSG_MAGIC_V2: {
1338                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1339                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1340                 pb->pb_handle = *handle;
1341                 return;
1342         }
1343         default:
1344                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1345         }
1346 }
1347 EXPORT_SYMBOL(lustre_msg_set_handle);
1348
1349 void lustre_msg_set_type(struct lustre_msg *msg, __u32 type)
1350 {
1351         switch (msg->lm_magic) {
1352         case LUSTRE_MSG_MAGIC_V2: {
1353                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1354                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1355                 pb->pb_type = type;
1356                 return;
1357         }
1358         default:
1359                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1360         }
1361 }
1362 EXPORT_SYMBOL(lustre_msg_set_type);
1363
1364 void lustre_msg_set_opc(struct lustre_msg *msg, __u32 opc)
1365 {
1366         switch (msg->lm_magic) {
1367         case LUSTRE_MSG_MAGIC_V2: {
1368                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1369                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1370                 pb->pb_opc = opc;
1371                 return;
1372         }
1373         default:
1374                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1375         }
1376 }
1377 EXPORT_SYMBOL(lustre_msg_set_opc);
1378
1379 void lustre_msg_set_last_xid(struct lustre_msg *msg, __u64 last_xid)
1380 {
1381         switch (msg->lm_magic) {
1382         case LUSTRE_MSG_MAGIC_V2: {
1383                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1384                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1385                 pb->pb_last_xid = last_xid;
1386                 return;
1387         }
1388         default:
1389                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1390         }
1391 }
1392 EXPORT_SYMBOL(lustre_msg_set_last_xid);
1393
1394 void lustre_msg_set_last_committed(struct lustre_msg *msg, __u64 last_committed)
1395 {
1396         switch (msg->lm_magic) {
1397         case LUSTRE_MSG_MAGIC_V2: {
1398                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1399                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1400                 pb->pb_last_committed = last_committed;
1401                 return;
1402         }
1403         default:
1404                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1405         }
1406 }
1407 EXPORT_SYMBOL(lustre_msg_set_last_committed);
1408
1409 void lustre_msg_set_versions(struct lustre_msg *msg, __u64 *versions)
1410 {
1411         switch (msg->lm_magic) {
1412         case LUSTRE_MSG_MAGIC_V1:
1413                 return;
1414         case LUSTRE_MSG_MAGIC_V2: {
1415                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1416                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1417                 pb->pb_pre_versions[0] = versions[0];
1418                 pb->pb_pre_versions[1] = versions[1];
1419                 pb->pb_pre_versions[2] = versions[2];
1420                 pb->pb_pre_versions[3] = versions[3];
1421                 return;
1422         }
1423         default:
1424                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1425         }
1426 }
1427 EXPORT_SYMBOL(lustre_msg_set_versions);
1428
1429 void lustre_msg_set_transno(struct lustre_msg *msg, __u64 transno)
1430 {
1431         switch (msg->lm_magic) {
1432         case LUSTRE_MSG_MAGIC_V2: {
1433                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1434                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1435                 pb->pb_transno = transno;
1436                 return;
1437         }
1438         default:
1439                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1440         }
1441 }
1442 EXPORT_SYMBOL(lustre_msg_set_transno);
1443
1444 void lustre_msg_set_status(struct lustre_msg *msg, __u32 status)
1445 {
1446         switch (msg->lm_magic) {
1447         case LUSTRE_MSG_MAGIC_V2: {
1448                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1449                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1450                 pb->pb_status = status;
1451                 return;
1452         }
1453         default:
1454                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1455         }
1456 }
1457 EXPORT_SYMBOL(lustre_msg_set_status);
1458
1459 void lustre_msg_set_conn_cnt(struct lustre_msg *msg, __u32 conn_cnt)
1460 {
1461         switch (msg->lm_magic) {
1462         case LUSTRE_MSG_MAGIC_V2: {
1463                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1464                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1465                 pb->pb_conn_cnt = conn_cnt;
1466                 return;
1467         }
1468         default:
1469                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1470         }
1471 }
1472 EXPORT_SYMBOL(lustre_msg_set_conn_cnt);
1473
1474 void lustre_msg_set_timeout(struct lustre_msg *msg, __u32 timeout)
1475 {
1476         switch (msg->lm_magic) {
1477         case LUSTRE_MSG_MAGIC_V1:
1478                 return;
1479         case LUSTRE_MSG_MAGIC_V2: {
1480                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1481                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1482                 pb->pb_timeout = timeout;
1483                 return;
1484         }
1485         default:
1486                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1487         }
1488 }
1489
1490 void lustre_msg_set_service_time(struct lustre_msg *msg, __u32 service_time)
1491 {
1492         switch (msg->lm_magic) {
1493         case LUSTRE_MSG_MAGIC_V1:
1494                 return;
1495         case LUSTRE_MSG_MAGIC_V2: {
1496                 struct ptlrpc_body *pb = lustre_msg_ptlrpc_body(msg);
1497                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1498                 pb->pb_service_time = service_time;
1499                 return;
1500         }
1501         default:
1502                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1503         }
1504 }
1505
1506 void lustre_msg_set_jobid(struct lustre_msg *msg, char *jobid)
1507 {
1508         switch (msg->lm_magic) {
1509         case LUSTRE_MSG_MAGIC_V1:
1510                 return;
1511         case LUSTRE_MSG_MAGIC_V2: {
1512                 __u32 opc = lustre_msg_get_opc(msg);
1513                 struct ptlrpc_body *pb;
1514
1515                 /* Don't set jobid for ldlm ast RPCs, they've been shrunk.
1516                  * See the comment in ptlrpc_request_pack(). */
1517                 if (!opc || opc == LDLM_BL_CALLBACK ||
1518                     opc == LDLM_CP_CALLBACK || opc == LDLM_GL_CALLBACK)
1519                         return;
1520
1521                 pb = lustre_msg_buf_v2(msg, MSG_PTLRPC_BODY_OFF,
1522                                        sizeof(struct ptlrpc_body));
1523                 LASSERTF(pb, "invalid msg %p: no ptlrpc body!\n", msg);
1524
1525                 if (jobid != NULL)
1526                         memcpy(pb->pb_jobid, jobid, JOBSTATS_JOBID_SIZE);
1527                 else if (pb->pb_jobid[0] == '\0')
1528                         lustre_get_jobid(pb->pb_jobid);
1529                 return;
1530         }
1531         default:
1532                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1533         }
1534 }
1535 EXPORT_SYMBOL(lustre_msg_set_jobid);
1536
1537 void lustre_msg_set_cksum(struct lustre_msg *msg, __u32 cksum)
1538 {
1539         switch (msg->lm_magic) {
1540         case LUSTRE_MSG_MAGIC_V1:
1541                 return;
1542         case LUSTRE_MSG_MAGIC_V2:
1543                 msg->lm_cksum = cksum;
1544                 return;
1545         default:
1546                 LASSERTF(0, "incorrect message magic: %08x\n", msg->lm_magic);
1547         }
1548 }
1549
1550
1551 void ptlrpc_request_set_replen(struct ptlrpc_request *req)
1552 {
1553         int count = req_capsule_filled_sizes(&req->rq_pill, RCL_SERVER);
1554
1555         req->rq_replen = lustre_msg_size(req->rq_reqmsg->lm_magic, count,
1556                                          req->rq_pill.rc_area[RCL_SERVER]);
1557         if (req->rq_reqmsg->lm_magic == LUSTRE_MSG_MAGIC_V2)
1558                 req->rq_reqmsg->lm_repsize = req->rq_replen;
1559 }
1560 EXPORT_SYMBOL(ptlrpc_request_set_replen);
1561
1562 void ptlrpc_req_set_repsize(struct ptlrpc_request *req, int count, __u32 *lens)
1563 {
1564         req->rq_replen = lustre_msg_size(req->rq_reqmsg->lm_magic, count, lens);
1565         if (req->rq_reqmsg->lm_magic == LUSTRE_MSG_MAGIC_V2)
1566                 req->rq_reqmsg->lm_repsize = req->rq_replen;
1567 }
1568 EXPORT_SYMBOL(ptlrpc_req_set_repsize);
1569
1570 /**
1571  * Send a remote set_info_async.
1572  *
1573  * This may go from client to server or server to client.
1574  */
1575 int do_set_info_async(struct obd_import *imp,
1576                       int opcode, int version,
1577                       u32 keylen, void *key,
1578                       u32 vallen, void *val,
1579                       struct ptlrpc_request_set *set)
1580 {
1581         struct ptlrpc_request *req;
1582         char *tmp;
1583         int rc;
1584
1585         req = ptlrpc_request_alloc(imp, &RQF_OBD_SET_INFO);
1586         if (req == NULL)
1587                 return -ENOMEM;
1588
1589         req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_KEY,
1590                              RCL_CLIENT, keylen);
1591         req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_VAL,
1592                              RCL_CLIENT, vallen);
1593         rc = ptlrpc_request_pack(req, version, opcode);
1594         if (rc) {
1595                 ptlrpc_request_free(req);
1596                 return rc;
1597         }
1598
1599         tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_KEY);
1600         memcpy(tmp, key, keylen);
1601         tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_VAL);
1602         memcpy(tmp, val, vallen);
1603
1604         ptlrpc_request_set_replen(req);
1605
1606         if (set) {
1607                 ptlrpc_set_add_req(set, req);
1608                 ptlrpc_check_set(NULL, set);
1609         } else {
1610                 rc = ptlrpc_queue_wait(req);
1611                 ptlrpc_req_finished(req);
1612         }
1613
1614         return rc;
1615 }
1616 EXPORT_SYMBOL(do_set_info_async);
1617
1618 /* byte flipping routines for all wire types declared in
1619  * lustre_idl.h implemented here.
1620  */
1621 void lustre_swab_ptlrpc_body(struct ptlrpc_body *b)
1622 {
1623         __swab32s(&b->pb_type);
1624         __swab32s(&b->pb_version);
1625         __swab32s(&b->pb_opc);
1626         __swab32s(&b->pb_status);
1627         __swab64s(&b->pb_last_xid);
1628         __swab64s(&b->pb_last_seen);
1629         __swab64s(&b->pb_last_committed);
1630         __swab64s(&b->pb_transno);
1631         __swab32s(&b->pb_flags);
1632         __swab32s(&b->pb_op_flags);
1633         __swab32s(&b->pb_conn_cnt);
1634         __swab32s(&b->pb_timeout);
1635         __swab32s(&b->pb_service_time);
1636         __swab32s(&b->pb_limit);
1637         __swab64s(&b->pb_slv);
1638         __swab64s(&b->pb_pre_versions[0]);
1639         __swab64s(&b->pb_pre_versions[1]);
1640         __swab64s(&b->pb_pre_versions[2]);
1641         __swab64s(&b->pb_pre_versions[3]);
1642         CLASSERT(offsetof(typeof(*b), pb_padding) != 0);
1643         /* While we need to maintain compatibility between
1644          * clients and servers without ptlrpc_body_v2 (< 2.3)
1645          * do not swab any fields beyond pb_jobid, as we are
1646          * using this swab function for both ptlrpc_body
1647          * and ptlrpc_body_v2. */
1648         CLASSERT(offsetof(typeof(*b), pb_jobid) != 0);
1649 }
1650 EXPORT_SYMBOL(lustre_swab_ptlrpc_body);
1651
1652 void lustre_swab_connect(struct obd_connect_data *ocd)
1653 {
1654         __swab64s(&ocd->ocd_connect_flags);
1655         __swab32s(&ocd->ocd_version);
1656         __swab32s(&ocd->ocd_grant);
1657         __swab64s(&ocd->ocd_ibits_known);
1658         __swab32s(&ocd->ocd_index);
1659         __swab32s(&ocd->ocd_brw_size);
1660         /* ocd_blocksize and ocd_inodespace don't need to be swabbed because
1661          * they are 8-byte values */
1662         __swab16s(&ocd->ocd_grant_extent);
1663         __swab32s(&ocd->ocd_unused);
1664         __swab64s(&ocd->ocd_transno);
1665         __swab32s(&ocd->ocd_group);
1666         __swab32s(&ocd->ocd_cksum_types);
1667         __swab32s(&ocd->ocd_instance);
1668         /* Fields after ocd_cksum_types are only accessible by the receiver
1669          * if the corresponding flag in ocd_connect_flags is set. Accessing
1670          * any field after ocd_maxbytes on the receiver without a valid flag
1671          * may result in out-of-bound memory access and kernel oops. */
1672         if (ocd->ocd_connect_flags & OBD_CONNECT_MAX_EASIZE)
1673                 __swab32s(&ocd->ocd_max_easize);
1674         if (ocd->ocd_connect_flags & OBD_CONNECT_MAXBYTES)
1675                 __swab64s(&ocd->ocd_maxbytes);
1676         CLASSERT(offsetof(typeof(*ocd), padding1) != 0);
1677         CLASSERT(offsetof(typeof(*ocd), padding2) != 0);
1678         CLASSERT(offsetof(typeof(*ocd), padding3) != 0);
1679         CLASSERT(offsetof(typeof(*ocd), padding4) != 0);
1680         CLASSERT(offsetof(typeof(*ocd), padding5) != 0);
1681         CLASSERT(offsetof(typeof(*ocd), padding6) != 0);
1682         CLASSERT(offsetof(typeof(*ocd), padding7) != 0);
1683         CLASSERT(offsetof(typeof(*ocd), padding8) != 0);
1684         CLASSERT(offsetof(typeof(*ocd), padding9) != 0);
1685         CLASSERT(offsetof(typeof(*ocd), paddingA) != 0);
1686         CLASSERT(offsetof(typeof(*ocd), paddingB) != 0);
1687         CLASSERT(offsetof(typeof(*ocd), paddingC) != 0);
1688         CLASSERT(offsetof(typeof(*ocd), paddingD) != 0);
1689         CLASSERT(offsetof(typeof(*ocd), paddingE) != 0);
1690         CLASSERT(offsetof(typeof(*ocd), paddingF) != 0);
1691 }
1692
1693 void lustre_swab_obdo(struct obdo *o)
1694 {
1695         __swab64s(&o->o_valid);
1696         lustre_swab_ost_id(&o->o_oi);
1697         __swab64s(&o->o_parent_seq);
1698         __swab64s(&o->o_size);
1699         __swab64s(&o->o_mtime);
1700         __swab64s(&o->o_atime);
1701         __swab64s(&o->o_ctime);
1702         __swab64s(&o->o_blocks);
1703         __swab64s(&o->o_grant);
1704         __swab32s(&o->o_blksize);
1705         __swab32s(&o->o_mode);
1706         __swab32s(&o->o_uid);
1707         __swab32s(&o->o_gid);
1708         __swab32s(&o->o_flags);
1709         __swab32s(&o->o_nlink);
1710         __swab32s(&o->o_parent_oid);
1711         __swab32s(&o->o_misc);
1712         __swab64s(&o->o_ioepoch);
1713         __swab32s(&o->o_stripe_idx);
1714         __swab32s(&o->o_parent_ver);
1715         /* o_handle is opaque */
1716         /* o_lcookie is swabbed elsewhere */
1717         __swab32s(&o->o_uid_h);
1718         __swab32s(&o->o_gid_h);
1719         __swab64s(&o->o_data_version);
1720         CLASSERT(offsetof(typeof(*o), o_padding_4) != 0);
1721         CLASSERT(offsetof(typeof(*o), o_padding_5) != 0);
1722         CLASSERT(offsetof(typeof(*o), o_padding_6) != 0);
1723
1724 }
1725 EXPORT_SYMBOL(lustre_swab_obdo);
1726
1727 void lustre_swab_obd_statfs(struct obd_statfs *os)
1728 {
1729         __swab64s(&os->os_type);
1730         __swab64s(&os->os_blocks);
1731         __swab64s(&os->os_bfree);
1732         __swab64s(&os->os_bavail);
1733         __swab64s(&os->os_files);
1734         __swab64s(&os->os_ffree);
1735         /* no need to swab os_fsid */
1736         __swab32s(&os->os_bsize);
1737         __swab32s(&os->os_namelen);
1738         __swab64s(&os->os_maxbytes);
1739         __swab32s(&os->os_state);
1740         CLASSERT(offsetof(typeof(*os), os_fprecreated) != 0);
1741         CLASSERT(offsetof(typeof(*os), os_spare2) != 0);
1742         CLASSERT(offsetof(typeof(*os), os_spare3) != 0);
1743         CLASSERT(offsetof(typeof(*os), os_spare4) != 0);
1744         CLASSERT(offsetof(typeof(*os), os_spare5) != 0);
1745         CLASSERT(offsetof(typeof(*os), os_spare6) != 0);
1746         CLASSERT(offsetof(typeof(*os), os_spare7) != 0);
1747         CLASSERT(offsetof(typeof(*os), os_spare8) != 0);
1748         CLASSERT(offsetof(typeof(*os), os_spare9) != 0);
1749 }
1750 EXPORT_SYMBOL(lustre_swab_obd_statfs);
1751
1752 void lustre_swab_obd_ioobj(struct obd_ioobj *ioo)
1753 {
1754         lustre_swab_ost_id(&ioo->ioo_oid);
1755         __swab32s(&ioo->ioo_max_brw);
1756         __swab32s(&ioo->ioo_bufcnt);
1757 }
1758 EXPORT_SYMBOL(lustre_swab_obd_ioobj);
1759
1760 void lustre_swab_niobuf_remote(struct niobuf_remote *nbr)
1761 {
1762         __swab64s(&nbr->offset);
1763         __swab32s(&nbr->len);
1764         __swab32s(&nbr->flags);
1765 }
1766 EXPORT_SYMBOL(lustre_swab_niobuf_remote);
1767
1768 void lustre_swab_ost_body(struct ost_body *b)
1769 {
1770         lustre_swab_obdo(&b->oa);
1771 }
1772 EXPORT_SYMBOL(lustre_swab_ost_body);
1773
1774 void lustre_swab_ost_last_id(u64 *id)
1775 {
1776         __swab64s(id);
1777 }
1778 EXPORT_SYMBOL(lustre_swab_ost_last_id);
1779
1780 void lustre_swab_generic_32s(__u32 *val)
1781 {
1782         __swab32s(val);
1783 }
1784 EXPORT_SYMBOL(lustre_swab_generic_32s);
1785
1786 void lustre_swab_gl_desc(union ldlm_gl_desc *desc)
1787 {
1788         lustre_swab_lu_fid(&desc->lquota_desc.gl_id.qid_fid);
1789         __swab64s(&desc->lquota_desc.gl_flags);
1790         __swab64s(&desc->lquota_desc.gl_ver);
1791         __swab64s(&desc->lquota_desc.gl_hardlimit);
1792         __swab64s(&desc->lquota_desc.gl_softlimit);
1793         __swab64s(&desc->lquota_desc.gl_time);
1794         CLASSERT(offsetof(typeof(desc->lquota_desc), gl_pad2) != 0);
1795 }
1796
1797 void lustre_swab_ost_lvb_v1(struct ost_lvb_v1 *lvb)
1798 {
1799         __swab64s(&lvb->lvb_size);
1800         __swab64s(&lvb->lvb_mtime);
1801         __swab64s(&lvb->lvb_atime);
1802         __swab64s(&lvb->lvb_ctime);
1803         __swab64s(&lvb->lvb_blocks);
1804 }
1805 EXPORT_SYMBOL(lustre_swab_ost_lvb_v1);
1806
1807 void lustre_swab_ost_lvb(struct ost_lvb *lvb)
1808 {
1809         __swab64s(&lvb->lvb_size);
1810         __swab64s(&lvb->lvb_mtime);
1811         __swab64s(&lvb->lvb_atime);
1812         __swab64s(&lvb->lvb_ctime);
1813         __swab64s(&lvb->lvb_blocks);
1814         __swab32s(&lvb->lvb_mtime_ns);
1815         __swab32s(&lvb->lvb_atime_ns);
1816         __swab32s(&lvb->lvb_ctime_ns);
1817         __swab32s(&lvb->lvb_padding);
1818 }
1819 EXPORT_SYMBOL(lustre_swab_ost_lvb);
1820
1821 void lustre_swab_lquota_lvb(struct lquota_lvb *lvb)
1822 {
1823         __swab64s(&lvb->lvb_flags);
1824         __swab64s(&lvb->lvb_id_may_rel);
1825         __swab64s(&lvb->lvb_id_rel);
1826         __swab64s(&lvb->lvb_id_qunit);
1827         __swab64s(&lvb->lvb_pad1);
1828 }
1829 EXPORT_SYMBOL(lustre_swab_lquota_lvb);
1830
1831 void lustre_swab_mdt_body(struct mdt_body *b)
1832 {
1833         lustre_swab_lu_fid(&b->fid1);
1834         lustre_swab_lu_fid(&b->fid2);
1835         /* handle is opaque */
1836         __swab64s(&b->valid);
1837         __swab64s(&b->size);
1838         __swab64s(&b->mtime);
1839         __swab64s(&b->atime);
1840         __swab64s(&b->ctime);
1841         __swab64s(&b->blocks);
1842         __swab64s(&b->ioepoch);
1843         __swab64s(&b->t_state);
1844         __swab32s(&b->fsuid);
1845         __swab32s(&b->fsgid);
1846         __swab32s(&b->capability);
1847         __swab32s(&b->mode);
1848         __swab32s(&b->uid);
1849         __swab32s(&b->gid);
1850         __swab32s(&b->flags);
1851         __swab32s(&b->rdev);
1852         __swab32s(&b->nlink);
1853         CLASSERT(offsetof(typeof(*b), unused2) != 0);
1854         __swab32s(&b->suppgid);
1855         __swab32s(&b->eadatasize);
1856         __swab32s(&b->aclsize);
1857         __swab32s(&b->max_mdsize);
1858         __swab32s(&b->max_cookiesize);
1859         __swab32s(&b->uid_h);
1860         __swab32s(&b->gid_h);
1861         CLASSERT(offsetof(typeof(*b), padding_5) != 0);
1862 }
1863 EXPORT_SYMBOL(lustre_swab_mdt_body);
1864
1865 void lustre_swab_mdt_ioepoch(struct mdt_ioepoch *b)
1866 {
1867         /* handle is opaque */
1868          __swab64s(&b->ioepoch);
1869          __swab32s(&b->flags);
1870          CLASSERT(offsetof(typeof(*b), padding) != 0);
1871 }
1872 EXPORT_SYMBOL(lustre_swab_mdt_ioepoch);
1873
1874 void lustre_swab_mgs_target_info(struct mgs_target_info *mti)
1875 {
1876         int i;
1877         __swab32s(&mti->mti_lustre_ver);
1878         __swab32s(&mti->mti_stripe_index);
1879         __swab32s(&mti->mti_config_ver);
1880         __swab32s(&mti->mti_flags);
1881         __swab32s(&mti->mti_instance);
1882         __swab32s(&mti->mti_nid_count);
1883         CLASSERT(sizeof(lnet_nid_t) == sizeof(__u64));
1884         for (i = 0; i < MTI_NIDS_MAX; i++)
1885                 __swab64s(&mti->mti_nids[i]);
1886 }
1887 EXPORT_SYMBOL(lustre_swab_mgs_target_info);
1888
1889 void lustre_swab_mgs_nidtbl_entry(struct mgs_nidtbl_entry *entry)
1890 {
1891         int i;
1892
1893         __swab64s(&entry->mne_version);
1894         __swab32s(&entry->mne_instance);
1895         __swab32s(&entry->mne_index);
1896         __swab32s(&entry->mne_length);
1897
1898         /* mne_nid_(count|type) must be one byte size because we're gonna
1899          * access it w/o swapping. */
1900         CLASSERT(sizeof(entry->mne_nid_count) == sizeof(__u8));
1901         CLASSERT(sizeof(entry->mne_nid_type) == sizeof(__u8));
1902
1903         /* remove this assertion if ipv6 is supported. */
1904         LASSERT(entry->mne_nid_type == 0);
1905         for (i = 0; i < entry->mne_nid_count; i++) {
1906                 CLASSERT(sizeof(lnet_nid_t) == sizeof(__u64));
1907                 __swab64s(&entry->u.nids[i]);
1908         }
1909 }
1910 EXPORT_SYMBOL(lustre_swab_mgs_nidtbl_entry);
1911
1912 void lustre_swab_mgs_config_body(struct mgs_config_body *body)
1913 {
1914         __swab64s(&body->mcb_offset);
1915         __swab32s(&body->mcb_units);
1916         __swab16s(&body->mcb_type);
1917 }
1918 EXPORT_SYMBOL(lustre_swab_mgs_config_body);
1919
1920 void lustre_swab_mgs_config_res(struct mgs_config_res *body)
1921 {
1922         __swab64s(&body->mcr_offset);
1923         __swab64s(&body->mcr_size);
1924 }
1925 EXPORT_SYMBOL(lustre_swab_mgs_config_res);
1926
1927 static void lustre_swab_obd_dqinfo(struct obd_dqinfo *i)
1928 {
1929         __swab64s(&i->dqi_bgrace);
1930         __swab64s(&i->dqi_igrace);
1931         __swab32s(&i->dqi_flags);
1932         __swab32s(&i->dqi_valid);
1933 }
1934
1935 static void lustre_swab_obd_dqblk(struct obd_dqblk *b)
1936 {
1937         __swab64s(&b->dqb_ihardlimit);
1938         __swab64s(&b->dqb_isoftlimit);
1939         __swab64s(&b->dqb_curinodes);
1940         __swab64s(&b->dqb_bhardlimit);
1941         __swab64s(&b->dqb_bsoftlimit);
1942         __swab64s(&b->dqb_curspace);
1943         __swab64s(&b->dqb_btime);
1944         __swab64s(&b->dqb_itime);
1945         __swab32s(&b->dqb_valid);
1946         CLASSERT(offsetof(typeof(*b), dqb_padding) != 0);
1947 }
1948
1949 void lustre_swab_obd_quotactl(struct obd_quotactl *q)
1950 {
1951         __swab32s(&q->qc_cmd);
1952         __swab32s(&q->qc_type);
1953         __swab32s(&q->qc_id);
1954         __swab32s(&q->qc_stat);
1955         lustre_swab_obd_dqinfo(&q->qc_dqinfo);
1956         lustre_swab_obd_dqblk(&q->qc_dqblk);
1957 }
1958 EXPORT_SYMBOL(lustre_swab_obd_quotactl);
1959
1960 void lustre_swab_mdt_remote_perm(struct mdt_remote_perm *p)
1961 {
1962         __swab32s(&p->rp_uid);
1963         __swab32s(&p->rp_gid);
1964         __swab32s(&p->rp_fsuid);
1965         __swab32s(&p->rp_fsuid_h);
1966         __swab32s(&p->rp_fsgid);
1967         __swab32s(&p->rp_fsgid_h);
1968         __swab32s(&p->rp_access_perm);
1969         __swab32s(&p->rp_padding);
1970 };
1971 EXPORT_SYMBOL(lustre_swab_mdt_remote_perm);
1972
1973 void lustre_swab_fid2path(struct getinfo_fid2path *gf)
1974 {
1975         lustre_swab_lu_fid(&gf->gf_fid);
1976         __swab64s(&gf->gf_recno);
1977         __swab32s(&gf->gf_linkno);
1978         __swab32s(&gf->gf_pathlen);
1979 }
1980 EXPORT_SYMBOL(lustre_swab_fid2path);
1981
1982 void lustre_swab_fiemap_extent(struct ll_fiemap_extent *fm_extent)
1983 {
1984         __swab64s(&fm_extent->fe_logical);
1985         __swab64s(&fm_extent->fe_physical);
1986         __swab64s(&fm_extent->fe_length);
1987         __swab32s(&fm_extent->fe_flags);
1988         __swab32s(&fm_extent->fe_device);
1989 }
1990
1991 void lustre_swab_fiemap(struct ll_user_fiemap *fiemap)
1992 {
1993         int i;
1994
1995         __swab64s(&fiemap->fm_start);
1996         __swab64s(&fiemap->fm_length);
1997         __swab32s(&fiemap->fm_flags);
1998         __swab32s(&fiemap->fm_mapped_extents);
1999         __swab32s(&fiemap->fm_extent_count);
2000         __swab32s(&fiemap->fm_reserved);
2001
2002         for (i = 0; i < fiemap->fm_mapped_extents; i++)
2003                 lustre_swab_fiemap_extent(&fiemap->fm_extents[i]);
2004 }
2005 EXPORT_SYMBOL(lustre_swab_fiemap);
2006
2007 void lustre_swab_idx_info(struct idx_info *ii)
2008 {
2009         __swab32s(&ii->ii_magic);
2010         __swab32s(&ii->ii_flags);
2011         __swab16s(&ii->ii_count);
2012         __swab32s(&ii->ii_attrs);
2013         lustre_swab_lu_fid(&ii->ii_fid);
2014         __swab64s(&ii->ii_version);
2015         __swab64s(&ii->ii_hash_start);
2016         __swab64s(&ii->ii_hash_end);
2017         __swab16s(&ii->ii_keysize);
2018         __swab16s(&ii->ii_recsize);
2019 }
2020
2021 void lustre_swab_lip_header(struct lu_idxpage *lip)
2022 {
2023         /* swab header */
2024         __swab32s(&lip->lip_magic);
2025         __swab16s(&lip->lip_flags);
2026         __swab16s(&lip->lip_nr);
2027 }
2028 EXPORT_SYMBOL(lustre_swab_lip_header);
2029
2030 void lustre_swab_mdt_rec_reint (struct mdt_rec_reint *rr)
2031 {
2032         __swab32s(&rr->rr_opcode);
2033         __swab32s(&rr->rr_cap);
2034         __swab32s(&rr->rr_fsuid);
2035         /* rr_fsuid_h is unused */
2036         __swab32s(&rr->rr_fsgid);
2037         /* rr_fsgid_h is unused */
2038         __swab32s(&rr->rr_suppgid1);
2039         /* rr_suppgid1_h is unused */
2040         __swab32s(&rr->rr_suppgid2);
2041         /* rr_suppgid2_h is unused */
2042         lustre_swab_lu_fid(&rr->rr_fid1);
2043         lustre_swab_lu_fid(&rr->rr_fid2);
2044         __swab64s(&rr->rr_mtime);
2045         __swab64s(&rr->rr_atime);
2046         __swab64s(&rr->rr_ctime);
2047         __swab64s(&rr->rr_size);
2048         __swab64s(&rr->rr_blocks);
2049         __swab32s(&rr->rr_bias);
2050         __swab32s(&rr->rr_mode);
2051         __swab32s(&rr->rr_flags);
2052         __swab32s(&rr->rr_flags_h);
2053         __swab32s(&rr->rr_umask);
2054
2055         CLASSERT(offsetof(typeof(*rr), rr_padding_4) != 0);
2056 };
2057 EXPORT_SYMBOL(lustre_swab_mdt_rec_reint);
2058
2059 void lustre_swab_lov_desc(struct lov_desc *ld)
2060 {
2061         __swab32s(&ld->ld_tgt_count);
2062         __swab32s(&ld->ld_active_tgt_count);
2063         __swab32s(&ld->ld_default_stripe_count);
2064         __swab32s(&ld->ld_pattern);
2065         __swab64s(&ld->ld_default_stripe_size);
2066         __swab64s(&ld->ld_default_stripe_offset);
2067         __swab32s(&ld->ld_qos_maxage);
2068         /* uuid endian insensitive */
2069 }
2070 EXPORT_SYMBOL(lustre_swab_lov_desc);
2071
2072 void lustre_swab_lmv_desc(struct lmv_desc *ld)
2073 {
2074         __swab32s(&ld->ld_tgt_count);
2075         __swab32s(&ld->ld_active_tgt_count);
2076         __swab32s(&ld->ld_default_stripe_count);
2077         __swab32s(&ld->ld_pattern);
2078         __swab64s(&ld->ld_default_hash_size);
2079         __swab32s(&ld->ld_qos_maxage);
2080         /* uuid endian insensitive */
2081 }
2082
2083 void lustre_swab_lmv_stripe_md(struct lmv_stripe_md *mea)
2084 {
2085         __swab32s(&mea->mea_magic);
2086         __swab32s(&mea->mea_count);
2087         __swab32s(&mea->mea_master);
2088         CLASSERT(offsetof(typeof(*mea), mea_padding) != 0);
2089 }
2090
2091 void lustre_swab_lmv_user_md(struct lmv_user_md *lum)
2092 {
2093         int i;
2094
2095         __swab32s(&lum->lum_magic);
2096         __swab32s(&lum->lum_stripe_count);
2097         __swab32s(&lum->lum_stripe_offset);
2098         __swab32s(&lum->lum_hash_type);
2099         __swab32s(&lum->lum_type);
2100         CLASSERT(offsetof(typeof(*lum), lum_padding1) != 0);
2101         CLASSERT(offsetof(typeof(*lum), lum_padding2) != 0);
2102         CLASSERT(offsetof(typeof(*lum), lum_padding3) != 0);
2103
2104         for (i = 0; i < lum->lum_stripe_count; i++) {
2105                 __swab32s(&lum->lum_objects[i].lum_mds);
2106                 lustre_swab_lu_fid(&lum->lum_objects[i].lum_fid);
2107         }
2108
2109 }
2110 EXPORT_SYMBOL(lustre_swab_lmv_user_md);
2111
2112 static void print_lum(struct lov_user_md *lum)
2113 {
2114         CDEBUG(D_OTHER, "lov_user_md %p:\n", lum);
2115         CDEBUG(D_OTHER, "\tlmm_magic: %#x\n", lum->lmm_magic);
2116         CDEBUG(D_OTHER, "\tlmm_pattern: %#x\n", lum->lmm_pattern);
2117         CDEBUG(D_OTHER, "\tlmm_object_id: %llu\n", lmm_oi_id(&lum->lmm_oi));
2118         CDEBUG(D_OTHER, "\tlmm_object_gr: %llu\n", lmm_oi_seq(&lum->lmm_oi));
2119         CDEBUG(D_OTHER, "\tlmm_stripe_size: %#x\n", lum->lmm_stripe_size);
2120         CDEBUG(D_OTHER, "\tlmm_stripe_count: %#x\n", lum->lmm_stripe_count);
2121         CDEBUG(D_OTHER, "\tlmm_stripe_offset/lmm_layout_gen: %#x\n",
2122                         lum->lmm_stripe_offset);
2123 }
2124
2125 static void lustre_swab_lmm_oi(struct ost_id *oi)
2126 {
2127         __swab64s(&oi->oi.oi_id);
2128         __swab64s(&oi->oi.oi_seq);
2129 }
2130
2131 static void lustre_swab_lov_user_md_common(struct lov_user_md_v1 *lum)
2132 {
2133         __swab32s(&lum->lmm_magic);
2134         __swab32s(&lum->lmm_pattern);
2135         lustre_swab_lmm_oi(&lum->lmm_oi);
2136         __swab32s(&lum->lmm_stripe_size);
2137         __swab16s(&lum->lmm_stripe_count);
2138         __swab16s(&lum->lmm_stripe_offset);
2139         print_lum(lum);
2140 }
2141
2142 void lustre_swab_lov_user_md_v1(struct lov_user_md_v1 *lum)
2143 {
2144         CDEBUG(D_IOCTL, "swabbing lov_user_md v1\n");
2145         lustre_swab_lov_user_md_common(lum);
2146 }
2147 EXPORT_SYMBOL(lustre_swab_lov_user_md_v1);
2148
2149 void lustre_swab_lov_user_md_v3(struct lov_user_md_v3 *lum)
2150 {
2151         CDEBUG(D_IOCTL, "swabbing lov_user_md v3\n");
2152         lustre_swab_lov_user_md_common((struct lov_user_md_v1 *)lum);
2153         /* lmm_pool_name nothing to do with char */
2154 }
2155 EXPORT_SYMBOL(lustre_swab_lov_user_md_v3);
2156
2157 void lustre_swab_lov_mds_md(struct lov_mds_md *lmm)
2158 {
2159         CDEBUG(D_IOCTL, "swabbing lov_mds_md\n");
2160         __swab32s(&lmm->lmm_magic);
2161         __swab32s(&lmm->lmm_pattern);
2162         lustre_swab_lmm_oi(&lmm->lmm_oi);
2163         __swab32s(&lmm->lmm_stripe_size);
2164         __swab16s(&lmm->lmm_stripe_count);
2165         __swab16s(&lmm->lmm_layout_gen);
2166 }
2167 EXPORT_SYMBOL(lustre_swab_lov_mds_md);
2168
2169 void lustre_swab_lov_user_md_objects(struct lov_user_ost_data *lod,
2170                                      int stripe_count)
2171 {
2172         int i;
2173
2174         for (i = 0; i < stripe_count; i++) {
2175                 lustre_swab_ost_id(&(lod[i].l_ost_oi));
2176                 __swab32s(&(lod[i].l_ost_gen));
2177                 __swab32s(&(lod[i].l_ost_idx));
2178         }
2179 }
2180 EXPORT_SYMBOL(lustre_swab_lov_user_md_objects);
2181
2182 void lustre_swab_ldlm_res_id(struct ldlm_res_id *id)
2183 {
2184         int i;
2185
2186         for (i = 0; i < RES_NAME_SIZE; i++)
2187                 __swab64s(&id->name[i]);
2188 }
2189 EXPORT_SYMBOL(lustre_swab_ldlm_res_id);
2190
2191 void lustre_swab_ldlm_policy_data(ldlm_wire_policy_data_t *d)
2192 {
2193         /* the lock data is a union and the first two fields are always an
2194          * extent so it's ok to process an LDLM_EXTENT and LDLM_FLOCK lock
2195          * data the same way. */
2196         __swab64s(&d->l_extent.start);
2197         __swab64s(&d->l_extent.end);
2198         __swab64s(&d->l_extent.gid);
2199         __swab64s(&d->l_flock.lfw_owner);
2200         __swab32s(&d->l_flock.lfw_pid);
2201 }
2202 EXPORT_SYMBOL(lustre_swab_ldlm_policy_data);
2203
2204 void lustre_swab_ldlm_intent(struct ldlm_intent *i)
2205 {
2206         __swab64s(&i->opc);
2207 }
2208 EXPORT_SYMBOL(lustre_swab_ldlm_intent);
2209
2210 void lustre_swab_ldlm_resource_desc(struct ldlm_resource_desc *r)
2211 {
2212         __swab32s(&r->lr_type);
2213         CLASSERT(offsetof(typeof(*r), lr_padding) != 0);
2214         lustre_swab_ldlm_res_id(&r->lr_name);
2215 }
2216 EXPORT_SYMBOL(lustre_swab_ldlm_resource_desc);
2217
2218 void lustre_swab_ldlm_lock_desc(struct ldlm_lock_desc *l)
2219 {
2220         lustre_swab_ldlm_resource_desc(&l->l_resource);
2221         __swab32s(&l->l_req_mode);
2222         __swab32s(&l->l_granted_mode);
2223         lustre_swab_ldlm_policy_data(&l->l_policy_data);
2224 }
2225 EXPORT_SYMBOL(lustre_swab_ldlm_lock_desc);
2226
2227 void lustre_swab_ldlm_request(struct ldlm_request *rq)
2228 {
2229         __swab32s(&rq->lock_flags);
2230         lustre_swab_ldlm_lock_desc(&rq->lock_desc);
2231         __swab32s(&rq->lock_count);
2232         /* lock_handle[] opaque */
2233 }
2234 EXPORT_SYMBOL(lustre_swab_ldlm_request);
2235
2236 void lustre_swab_ldlm_reply(struct ldlm_reply *r)
2237 {
2238         __swab32s(&r->lock_flags);
2239         CLASSERT(offsetof(typeof(*r), lock_padding) != 0);
2240         lustre_swab_ldlm_lock_desc(&r->lock_desc);
2241         /* lock_handle opaque */
2242         __swab64s(&r->lock_policy_res1);
2243         __swab64s(&r->lock_policy_res2);
2244 }
2245 EXPORT_SYMBOL(lustre_swab_ldlm_reply);
2246
2247 void lustre_swab_quota_body(struct quota_body *b)
2248 {
2249         lustre_swab_lu_fid(&b->qb_fid);
2250         lustre_swab_lu_fid((struct lu_fid *)&b->qb_id);
2251         __swab32s(&b->qb_flags);
2252         __swab64s(&b->qb_count);
2253         __swab64s(&b->qb_usage);
2254         __swab64s(&b->qb_slv_ver);
2255 }
2256
2257 /* Dump functions */
2258 void dump_ioo(struct obd_ioobj *ioo)
2259 {
2260         CDEBUG(D_RPCTRACE,
2261                "obd_ioobj: ioo_oid=" DOSTID ", ioo_max_brw=%#x, ioo_bufct=%d\n",
2262                POSTID(&ioo->ioo_oid), ioo->ioo_max_brw,
2263                ioo->ioo_bufcnt);
2264 }
2265 EXPORT_SYMBOL(dump_ioo);
2266
2267 void dump_rniobuf(struct niobuf_remote *nb)
2268 {
2269         CDEBUG(D_RPCTRACE, "niobuf_remote: offset=%llu, len=%d, flags=%x\n",
2270                nb->offset, nb->len, nb->flags);
2271 }
2272 EXPORT_SYMBOL(dump_rniobuf);
2273
2274 void dump_obdo(struct obdo *oa)
2275 {
2276         __u32 valid = oa->o_valid;
2277
2278         CDEBUG(D_RPCTRACE, "obdo: o_valid = %08x\n", valid);
2279         if (valid & OBD_MD_FLID)
2280                 CDEBUG(D_RPCTRACE, "obdo: id = "DOSTID"\n", POSTID(&oa->o_oi));
2281         if (valid & OBD_MD_FLFID)
2282                 CDEBUG(D_RPCTRACE, "obdo: o_parent_seq = %#llx\n",
2283                        oa->o_parent_seq);
2284         if (valid & OBD_MD_FLSIZE)
2285                 CDEBUG(D_RPCTRACE, "obdo: o_size = %lld\n", oa->o_size);
2286         if (valid & OBD_MD_FLMTIME)
2287                 CDEBUG(D_RPCTRACE, "obdo: o_mtime = %lld\n", oa->o_mtime);
2288         if (valid & OBD_MD_FLATIME)
2289                 CDEBUG(D_RPCTRACE, "obdo: o_atime = %lld\n", oa->o_atime);
2290         if (valid & OBD_MD_FLCTIME)
2291                 CDEBUG(D_RPCTRACE, "obdo: o_ctime = %lld\n", oa->o_ctime);
2292         if (valid & OBD_MD_FLBLOCKS)   /* allocation of space */
2293                 CDEBUG(D_RPCTRACE, "obdo: o_blocks = %lld\n", oa->o_blocks);
2294         if (valid & OBD_MD_FLGRANT)
2295                 CDEBUG(D_RPCTRACE, "obdo: o_grant = %lld\n", oa->o_grant);
2296         if (valid & OBD_MD_FLBLKSZ)
2297                 CDEBUG(D_RPCTRACE, "obdo: o_blksize = %d\n", oa->o_blksize);
2298         if (valid & (OBD_MD_FLTYPE | OBD_MD_FLMODE))
2299                 CDEBUG(D_RPCTRACE, "obdo: o_mode = %o\n",
2300                        oa->o_mode & ((valid & OBD_MD_FLTYPE ?  S_IFMT : 0) |
2301                                      (valid & OBD_MD_FLMODE ? ~S_IFMT : 0)));
2302         if (valid & OBD_MD_FLUID)
2303                 CDEBUG(D_RPCTRACE, "obdo: o_uid = %u\n", oa->o_uid);
2304         if (valid & OBD_MD_FLUID)
2305                 CDEBUG(D_RPCTRACE, "obdo: o_uid_h = %u\n", oa->o_uid_h);
2306         if (valid & OBD_MD_FLGID)
2307                 CDEBUG(D_RPCTRACE, "obdo: o_gid = %u\n", oa->o_gid);
2308         if (valid & OBD_MD_FLGID)
2309                 CDEBUG(D_RPCTRACE, "obdo: o_gid_h = %u\n", oa->o_gid_h);
2310         if (valid & OBD_MD_FLFLAGS)
2311                 CDEBUG(D_RPCTRACE, "obdo: o_flags = %x\n", oa->o_flags);
2312         if (valid & OBD_MD_FLNLINK)
2313                 CDEBUG(D_RPCTRACE, "obdo: o_nlink = %u\n", oa->o_nlink);
2314         else if (valid & OBD_MD_FLCKSUM)
2315                 CDEBUG(D_RPCTRACE, "obdo: o_checksum (o_nlink) = %u\n",
2316                        oa->o_nlink);
2317         if (valid & OBD_MD_FLGENER)
2318                 CDEBUG(D_RPCTRACE, "obdo: o_parent_oid = %x\n",
2319                        oa->o_parent_oid);
2320         if (valid & OBD_MD_FLEPOCH)
2321                 CDEBUG(D_RPCTRACE, "obdo: o_ioepoch = %lld\n",
2322                        oa->o_ioepoch);
2323         if (valid & OBD_MD_FLFID) {
2324                 CDEBUG(D_RPCTRACE, "obdo: o_stripe_idx = %u\n",
2325                        oa->o_stripe_idx);
2326                 CDEBUG(D_RPCTRACE, "obdo: o_parent_ver = %x\n",
2327                        oa->o_parent_ver);
2328         }
2329         if (valid & OBD_MD_FLHANDLE)
2330                 CDEBUG(D_RPCTRACE, "obdo: o_handle = %lld\n",
2331                        oa->o_handle.cookie);
2332         if (valid & OBD_MD_FLCOOKIE)
2333                 CDEBUG(D_RPCTRACE, "obdo: o_lcookie = (llog_cookie dumping not yet implemented)\n");
2334 }
2335 EXPORT_SYMBOL(dump_obdo);
2336
2337 void dump_ost_body(struct ost_body *ob)
2338 {
2339         dump_obdo(&ob->oa);
2340 }
2341 EXPORT_SYMBOL(dump_ost_body);
2342
2343 void dump_rcs(__u32 *rc)
2344 {
2345         CDEBUG(D_RPCTRACE, "rmf_rcs: %d\n", *rc);
2346 }
2347 EXPORT_SYMBOL(dump_rcs);
2348
2349 static inline int req_ptlrpc_body_swabbed(struct ptlrpc_request *req)
2350 {
2351         LASSERT(req->rq_reqmsg);
2352
2353         switch (req->rq_reqmsg->lm_magic) {
2354         case LUSTRE_MSG_MAGIC_V2:
2355                 return lustre_req_swabbed(req, MSG_PTLRPC_BODY_OFF);
2356         default:
2357                 CERROR("bad lustre msg magic: %#08X\n",
2358                        req->rq_reqmsg->lm_magic);
2359         }
2360         return 0;
2361 }
2362
2363 static inline int rep_ptlrpc_body_swabbed(struct ptlrpc_request *req)
2364 {
2365         LASSERT(req->rq_repmsg);
2366
2367         switch (req->rq_repmsg->lm_magic) {
2368         case LUSTRE_MSG_MAGIC_V2:
2369                 return lustre_rep_swabbed(req, MSG_PTLRPC_BODY_OFF);
2370         default:
2371                 /* uninitialized yet */
2372                 return 0;
2373         }
2374 }
2375
2376 void _debug_req(struct ptlrpc_request *req,
2377                 struct libcfs_debug_msg_data *msgdata,
2378                 const char *fmt, ...)
2379 {
2380         int req_ok = req->rq_reqmsg != NULL;
2381         int rep_ok = req->rq_repmsg != NULL;
2382         lnet_nid_t nid = LNET_NID_ANY;
2383         va_list args;
2384
2385         if (ptlrpc_req_need_swab(req)) {
2386                 req_ok = req_ok && req_ptlrpc_body_swabbed(req);
2387                 rep_ok = rep_ok && rep_ptlrpc_body_swabbed(req);
2388         }
2389
2390         if (req->rq_import && req->rq_import->imp_connection)
2391                 nid = req->rq_import->imp_connection->c_peer.nid;
2392         else if (req->rq_export && req->rq_export->exp_connection)
2393                 nid = req->rq_export->exp_connection->c_peer.nid;
2394
2395         va_start(args, fmt);
2396         libcfs_debug_vmsg2(msgdata, fmt, args,
2397                            " req@%p x%llu/t%lld(%lld) o%d->%s@%s:%d/%d lens %d/%d e %d to %d dl " CFS_TIME_T " ref %d fl " REQ_FLAGS_FMT "/%x/%x rc %d/%d\n",
2398                            req, req->rq_xid, req->rq_transno,
2399                            req_ok ? lustre_msg_get_transno(req->rq_reqmsg) : 0,
2400                            req_ok ? lustre_msg_get_opc(req->rq_reqmsg) : -1,
2401                            req->rq_import ?
2402                            req->rq_import->imp_obd->obd_name :
2403                            req->rq_export ?
2404                            req->rq_export->exp_client_uuid.uuid :
2405                            "<?>",
2406                            libcfs_nid2str(nid),
2407                            req->rq_request_portal, req->rq_reply_portal,
2408                            req->rq_reqlen, req->rq_replen,
2409                            req->rq_early_count, req->rq_timedout,
2410                            req->rq_deadline,
2411                            atomic_read(&req->rq_refcount),
2412                            DEBUG_REQ_FLAGS(req),
2413                            req_ok ? lustre_msg_get_flags(req->rq_reqmsg) : -1,
2414                            rep_ok ? lustre_msg_get_flags(req->rq_repmsg) : -1,
2415                            req->rq_status,
2416                            rep_ok ? lustre_msg_get_status(req->rq_repmsg) : -1);
2417         va_end(args);
2418 }
2419 EXPORT_SYMBOL(_debug_req);
2420
2421 void lustre_swab_lustre_capa(struct lustre_capa *c)
2422 {
2423         lustre_swab_lu_fid(&c->lc_fid);
2424         __swab64s(&c->lc_opc);
2425         __swab64s(&c->lc_uid);
2426         __swab64s(&c->lc_gid);
2427         __swab32s(&c->lc_flags);
2428         __swab32s(&c->lc_keyid);
2429         __swab32s(&c->lc_timeout);
2430         __swab32s(&c->lc_expiry);
2431 }
2432 EXPORT_SYMBOL(lustre_swab_lustre_capa);
2433
2434 void lustre_swab_lustre_capa_key(struct lustre_capa_key *k)
2435 {
2436         __swab64s(&k->lk_seq);
2437         __swab32s(&k->lk_keyid);
2438         CLASSERT(offsetof(typeof(*k), lk_padding) != 0);
2439 }
2440 EXPORT_SYMBOL(lustre_swab_lustre_capa_key);
2441
2442 void lustre_swab_hsm_user_state(struct hsm_user_state *state)
2443 {
2444         __swab32s(&state->hus_states);
2445         __swab32s(&state->hus_archive_id);
2446 }
2447 EXPORT_SYMBOL(lustre_swab_hsm_user_state);
2448
2449 void lustre_swab_hsm_state_set(struct hsm_state_set *hss)
2450 {
2451         __swab32s(&hss->hss_valid);
2452         __swab64s(&hss->hss_setmask);
2453         __swab64s(&hss->hss_clearmask);
2454         __swab32s(&hss->hss_archive_id);
2455 }
2456 EXPORT_SYMBOL(lustre_swab_hsm_state_set);
2457
2458 void lustre_swab_hsm_extent(struct hsm_extent *extent)
2459 {
2460         __swab64s(&extent->offset);
2461         __swab64s(&extent->length);
2462 }
2463
2464 void lustre_swab_hsm_current_action(struct hsm_current_action *action)
2465 {
2466         __swab32s(&action->hca_state);
2467         __swab32s(&action->hca_action);
2468         lustre_swab_hsm_extent(&action->hca_location);
2469 }
2470 EXPORT_SYMBOL(lustre_swab_hsm_current_action);
2471
2472 void lustre_swab_hsm_user_item(struct hsm_user_item *hui)
2473 {
2474         lustre_swab_lu_fid(&hui->hui_fid);
2475         lustre_swab_hsm_extent(&hui->hui_extent);
2476 }
2477 EXPORT_SYMBOL(lustre_swab_hsm_user_item);
2478
2479 void lustre_swab_layout_intent(struct layout_intent *li)
2480 {
2481         __swab32s(&li->li_opc);
2482         __swab32s(&li->li_flags);
2483         __swab64s(&li->li_start);
2484         __swab64s(&li->li_end);
2485 }
2486 EXPORT_SYMBOL(lustre_swab_layout_intent);
2487
2488 void lustre_swab_hsm_progress_kernel(struct hsm_progress_kernel *hpk)
2489 {
2490         lustre_swab_lu_fid(&hpk->hpk_fid);
2491         __swab64s(&hpk->hpk_cookie);
2492         __swab64s(&hpk->hpk_extent.offset);
2493         __swab64s(&hpk->hpk_extent.length);
2494         __swab16s(&hpk->hpk_flags);
2495         __swab16s(&hpk->hpk_errval);
2496 }
2497 EXPORT_SYMBOL(lustre_swab_hsm_progress_kernel);
2498
2499 void lustre_swab_hsm_request(struct hsm_request *hr)
2500 {
2501         __swab32s(&hr->hr_action);
2502         __swab32s(&hr->hr_archive_id);
2503         __swab64s(&hr->hr_flags);
2504         __swab32s(&hr->hr_itemcount);
2505         __swab32s(&hr->hr_data_len);
2506 }
2507 EXPORT_SYMBOL(lustre_swab_hsm_request);
2508
2509 void lustre_swab_update_buf(struct update_buf *ub)
2510 {
2511         __swab32s(&ub->ub_magic);
2512         __swab32s(&ub->ub_count);
2513 }
2514 EXPORT_SYMBOL(lustre_swab_update_buf);
2515
2516 void lustre_swab_update_reply_buf(struct update_reply *ur)
2517 {
2518         int i;
2519
2520         __swab32s(&ur->ur_version);
2521         __swab32s(&ur->ur_count);
2522         for (i = 0; i < ur->ur_count; i++)
2523                 __swab32s(&ur->ur_lens[i]);
2524 }
2525 EXPORT_SYMBOL(lustre_swab_update_reply_buf);
2526
2527 void lustre_swab_swap_layouts(struct mdc_swap_layouts *msl)
2528 {
2529         __swab64s(&msl->msl_flags);
2530 }
2531 EXPORT_SYMBOL(lustre_swab_swap_layouts);
2532
2533 void lustre_swab_close_data(struct close_data *cd)
2534 {
2535         lustre_swab_lu_fid(&cd->cd_fid);
2536         __swab64s(&cd->cd_data_version);
2537 }
2538 EXPORT_SYMBOL(lustre_swab_close_data);