drivers/staging/lustre/lustre/ptlrpc/pack_generic.c

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