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