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