drivers/staging/lustre/lnet/selftest/brw_test.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) 2007, 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  * lnet/selftest/brw_test.c
  37  *
  38  * Author: Isaac Huang <isaac@clusterfs.com>
  39  */
  40
  41 #include "selftest.h"
  42
  43 static int brw_srv_workitems = SFW_TEST_WI_MAX;
  44 module_param(brw_srv_workitems, int, 0644);
  45 MODULE_PARM_DESC(brw_srv_workitems, "# BRW server workitems");
  46
  47 static int brw_inject_errors;
  48 module_param(brw_inject_errors, int, 0644);
  49 MODULE_PARM_DESC(brw_inject_errors, "# data errors to inject randomly, zero by default");
  50
  51 static void
  52 brw_client_fini(sfw_test_instance_t *tsi)
  53 {
  54         srpc_bulk_t     *bulk;
  55         sfw_test_unit_t *tsu;
  56
  57         LASSERT(tsi->tsi_is_client);
  58
  59         list_for_each_entry(tsu, &tsi->tsi_units, tsu_list) {
  60                 bulk = tsu->tsu_private;
  61                 if (bulk == NULL)
  62                         continue;
  63
  64                 srpc_free_bulk(bulk);
  65                 tsu->tsu_private = NULL;
  66         }
  67 }
  68
  69 static int
  70 brw_client_init(sfw_test_instance_t *tsi)
  71 {
  72         sfw_session_t    *sn = tsi->tsi_batch->bat_session;
  73         int               flags;
  74         int               npg;
  75         int               len;
  76         int               opc;
  77         srpc_bulk_t      *bulk;
  78         sfw_test_unit_t  *tsu;
  79
  80         LASSERT(sn != NULL);
  81         LASSERT(tsi->tsi_is_client);
  82
  83         if ((sn->sn_features & LST_FEAT_BULK_LEN) == 0) {
  84                 test_bulk_req_t  *breq = &tsi->tsi_u.bulk_v0;
  85
  86                 opc   = breq->blk_opc;
  87                 flags = breq->blk_flags;
  88                 npg   = breq->blk_npg;
  89                 /* NB: this is not going to work for variable page size,
  90                  * but we have to keep it for compatibility */
  91                 len   = npg * PAGE_CACHE_SIZE;
  92
  93         } else {
  94                 test_bulk_req_v1_t  *breq = &tsi->tsi_u.bulk_v1;
  95
  96                 /* I should never get this step if it's unknown feature
  97                  * because make_session will reject unknown feature */
  98                 LASSERT((sn->sn_features & ~LST_FEATS_MASK) == 0);
  99
 100                 opc   = breq->blk_opc;
 101                 flags = breq->blk_flags;
 102                 len   = breq->blk_len;
 103                 npg   = (len + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
 104         }
 105
 106         if (npg > LNET_MAX_IOV || npg <= 0)
 107                 return -EINVAL;
 108
 109         if (opc != LST_BRW_READ && opc != LST_BRW_WRITE)
 110                 return -EINVAL;
 111
 112         if (flags != LST_BRW_CHECK_NONE &&
 113             flags != LST_BRW_CHECK_FULL && flags != LST_BRW_CHECK_SIMPLE)
 114                 return -EINVAL;
 115
 116         list_for_each_entry(tsu, &tsi->tsi_units, tsu_list) {
 117                 bulk = srpc_alloc_bulk(lnet_cpt_of_nid(tsu->tsu_dest.nid),
 118                                        npg, len, opc == LST_BRW_READ);
 119                 if (bulk == NULL) {
 120                         brw_client_fini(tsi);
 121                         return -ENOMEM;
 122                 }
 123
 124                 tsu->tsu_private = bulk;
 125         }
 126
 127         return 0;
 128 }
 129
 130 #define BRW_POISON      0xbeefbeefbeefbeefULL
 131 #define BRW_MAGIC       0xeeb0eeb1eeb2eeb3ULL
 132 #define BRW_MSIZE       sizeof(__u64)
 133
 134 static int
 135 brw_inject_one_error(void)
 136 {
 137         struct timeval tv;
 138
 139         if (brw_inject_errors <= 0)
 140                 return 0;
 141
 142         do_gettimeofday(&tv);
 143
 144         if ((tv.tv_usec & 1) == 0)
 145                 return 0;
 146
 147         return brw_inject_errors--;
 148 }
 149
 150 static void
 151 brw_fill_page(struct page *pg, int pattern, __u64 magic)
 152 {
 153         char *addr = page_address(pg);
 154         int   i;
 155
 156         LASSERT(addr != NULL);
 157
 158         if (pattern == LST_BRW_CHECK_NONE)
 159                 return;
 160
 161         if (magic == BRW_MAGIC)
 162                 magic += brw_inject_one_error();
 163
 164         if (pattern == LST_BRW_CHECK_SIMPLE) {
 165                 memcpy(addr, &magic, BRW_MSIZE);
 166                 addr += PAGE_CACHE_SIZE - BRW_MSIZE;
 167                 memcpy(addr, &magic, BRW_MSIZE);
 168                 return;
 169         }
 170
 171         if (pattern == LST_BRW_CHECK_FULL) {
 172                 for (i = 0; i < PAGE_CACHE_SIZE / BRW_MSIZE; i++)
 173                         memcpy(addr + i * BRW_MSIZE, &magic, BRW_MSIZE);
 174                 return;
 175         }
 176
 177         LBUG();
 178         return;
 179 }
 180
 181 static int
 182 brw_check_page(struct page *pg, int pattern, __u64 magic)
 183 {
 184         char  *addr = page_address(pg);
 185         __u64  data = 0; /* make compiler happy */
 186         int    i;
 187
 188         LASSERT(addr != NULL);
 189
 190         if (pattern == LST_BRW_CHECK_NONE)
 191                 return 0;
 192
 193         if (pattern == LST_BRW_CHECK_SIMPLE) {
 194                 data = *((__u64 *) addr);
 195                 if (data != magic)
 196                         goto bad_data;
 197
 198                 addr += PAGE_CACHE_SIZE - BRW_MSIZE;
 199                 data = *((__u64 *) addr);
 200                 if (data != magic)
 201                         goto bad_data;
 202
 203                 return 0;
 204         }
 205
 206         if (pattern == LST_BRW_CHECK_FULL) {
 207                 for (i = 0; i < PAGE_CACHE_SIZE / BRW_MSIZE; i++) {
 208                         data = *(((__u64 *) addr) + i);
 209                         if (data != magic)
 210                                 goto bad_data;
 211                 }
 212
 213                 return 0;
 214         }
 215
 216         LBUG();
 217
 218 bad_data:
 219         CERROR("Bad data in page %p: %#llx, %#llx expected\n",
 220                 pg, data, magic);
 221         return 1;
 222 }
 223
 224 void
 225 brw_fill_bulk(srpc_bulk_t *bk, int pattern, __u64 magic)
 226 {
 227         int      i;
 228         struct page *pg;
 229
 230         for (i = 0; i < bk->bk_niov; i++) {
 231                 pg = bk->bk_iovs[i].kiov_page;
 232                 brw_fill_page(pg, pattern, magic);
 233         }
 234 }
 235
 236 int
 237 brw_check_bulk(srpc_bulk_t *bk, int pattern, __u64 magic)
 238 {
 239         int      i;
 240         struct page *pg;
 241
 242         for (i = 0; i < bk->bk_niov; i++) {
 243                 pg = bk->bk_iovs[i].kiov_page;
 244                 if (brw_check_page(pg, pattern, magic) != 0) {
 245                         CERROR("Bulk page %p (%d/%d) is corrupted!\n",
 246                                 pg, i, bk->bk_niov);
 247                         return 1;
 248                 }
 249         }
 250
 251         return 0;
 252 }
 253
 254 static int
 255 brw_client_prep_rpc(sfw_test_unit_t *tsu,
 256                      lnet_process_id_t dest, srpc_client_rpc_t **rpcpp)
 257 {
 258         srpc_bulk_t      *bulk = tsu->tsu_private;
 259         sfw_test_instance_t *tsi = tsu->tsu_instance;
 260         sfw_session_t       *sn = tsi->tsi_batch->bat_session;
 261         srpc_client_rpc_t   *rpc;
 262         srpc_brw_reqst_t    *req;
 263         int                  flags;
 264         int                  npg;
 265         int                  len;
 266         int                  opc;
 267         int                  rc;
 268
 269         LASSERT(sn != NULL);
 270         LASSERT(bulk != NULL);
 271
 272         if ((sn->sn_features & LST_FEAT_BULK_LEN) == 0) {
 273                 test_bulk_req_t *breq = &tsi->tsi_u.bulk_v0;
 274
 275                 opc   = breq->blk_opc;
 276                 flags = breq->blk_flags;
 277                 npg   = breq->blk_npg;
 278                 len   = npg * PAGE_CACHE_SIZE;
 279
 280         } else {
 281                 test_bulk_req_v1_t  *breq = &tsi->tsi_u.bulk_v1;
 282
 283                 /* I should never get this step if it's unknown feature
 284                  * because make_session will reject unknown feature */
 285                 LASSERT((sn->sn_features & ~LST_FEATS_MASK) == 0);
 286
 287                 opc   = breq->blk_opc;
 288                 flags = breq->blk_flags;
 289                 len   = breq->blk_len;
 290                 npg   = (len + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
 291         }
 292
 293         rc = sfw_create_test_rpc(tsu, dest, sn->sn_features, npg, len, &rpc);
 294         if (rc != 0)
 295                 return rc;
 296
 297         memcpy(&rpc->crpc_bulk, bulk, offsetof(srpc_bulk_t, bk_iovs[npg]));
 298         if (opc == LST_BRW_WRITE)
 299                 brw_fill_bulk(&rpc->crpc_bulk, flags, BRW_MAGIC);
 300         else
 301                 brw_fill_bulk(&rpc->crpc_bulk, flags, BRW_POISON);
 302
 303         req = &rpc->crpc_reqstmsg.msg_body.brw_reqst;
 304         req->brw_flags = flags;
 305         req->brw_rw    = opc;
 306         req->brw_len   = len;
 307
 308         *rpcpp = rpc;
 309         return 0;
 310 }
 311
 312 static void
 313 brw_client_done_rpc(sfw_test_unit_t *tsu, srpc_client_rpc_t *rpc)
 314 {
 315         __u64           magic = BRW_MAGIC;
 316         sfw_test_instance_t *tsi = tsu->tsu_instance;
 317         sfw_session_t       *sn = tsi->tsi_batch->bat_session;
 318         srpc_msg_t        *msg = &rpc->crpc_replymsg;
 319         srpc_brw_reply_t    *reply = &msg->msg_body.brw_reply;
 320         srpc_brw_reqst_t    *reqst = &rpc->crpc_reqstmsg.msg_body.brw_reqst;
 321
 322         LASSERT(sn != NULL);
 323
 324         if (rpc->crpc_status != 0) {
 325                 CERROR("BRW RPC to %s failed with %d\n",
 326                         libcfs_id2str(rpc->crpc_dest), rpc->crpc_status);
 327                 if (!tsi->tsi_stopping) /* rpc could have been aborted */
 328                         atomic_inc(&sn->sn_brw_errors);
 329                 goto out;
 330         }
 331
 332         if (msg->msg_magic != SRPC_MSG_MAGIC) {
 333                 __swab64s(&magic);
 334                 __swab32s(&reply->brw_status);
 335         }
 336
 337         CDEBUG(reply->brw_status ? D_WARNING : D_NET,
 338                 "BRW RPC to %s finished with brw_status: %d\n",
 339                 libcfs_id2str(rpc->crpc_dest), reply->brw_status);
 340
 341         if (reply->brw_status != 0) {
 342                 atomic_inc(&sn->sn_brw_errors);
 343                 rpc->crpc_status = -(int)reply->brw_status;
 344                 goto out;
 345         }
 346
 347         if (reqst->brw_rw == LST_BRW_WRITE)
 348                 goto out;
 349
 350         if (brw_check_bulk(&rpc->crpc_bulk, reqst->brw_flags, magic) != 0) {
 351                 CERROR("Bulk data from %s is corrupted!\n",
 352                         libcfs_id2str(rpc->crpc_dest));
 353                 atomic_inc(&sn->sn_brw_errors);
 354                 rpc->crpc_status = -EBADMSG;
 355         }
 356
 357 out:
 358         return;
 359 }
 360
 361 void
 362 brw_server_rpc_done(srpc_server_rpc_t *rpc)
 363 {
 364         srpc_bulk_t *blk = rpc->srpc_bulk;
 365
 366         if (blk == NULL)
 367                 return;
 368
 369         if (rpc->srpc_status != 0)
 370                 CERROR("Bulk transfer %s %s has failed: %d\n",
 371                         blk->bk_sink ? "from" : "to",
 372                         libcfs_id2str(rpc->srpc_peer), rpc->srpc_status);
 373         else
 374                 CDEBUG(D_NET, "Transferred %d pages bulk data %s %s\n",
 375                         blk->bk_niov, blk->bk_sink ? "from" : "to",
 376                         libcfs_id2str(rpc->srpc_peer));
 377
 378         sfw_free_pages(rpc);
 379 }
 380
 381 int
 382 brw_bulk_ready(srpc_server_rpc_t *rpc, int status)
 383 {
 384         __u64        magic = BRW_MAGIC;
 385         srpc_brw_reply_t *reply = &rpc->srpc_replymsg.msg_body.brw_reply;
 386         srpc_brw_reqst_t *reqst;
 387         srpc_msg_t       *reqstmsg;
 388
 389         LASSERT(rpc->srpc_bulk != NULL);
 390         LASSERT(rpc->srpc_reqstbuf != NULL);
 391
 392         reqstmsg = &rpc->srpc_reqstbuf->buf_msg;
 393         reqst = &reqstmsg->msg_body.brw_reqst;
 394
 395         if (status != 0) {
 396                 CERROR("BRW bulk %s failed for RPC from %s: %d\n",
 397                         reqst->brw_rw == LST_BRW_READ ? "READ" : "WRITE",
 398                         libcfs_id2str(rpc->srpc_peer), status);
 399                 return -EIO;
 400         }
 401
 402         if (reqst->brw_rw == LST_BRW_READ)
 403                 return 0;
 404
 405         if (reqstmsg->msg_magic != SRPC_MSG_MAGIC)
 406                 __swab64s(&magic);
 407
 408         if (brw_check_bulk(rpc->srpc_bulk, reqst->brw_flags, magic) != 0) {
 409                 CERROR("Bulk data from %s is corrupted!\n",
 410                         libcfs_id2str(rpc->srpc_peer));
 411                 reply->brw_status = EBADMSG;
 412         }
 413
 414         return 0;
 415 }
 416
 417 int
 418 brw_server_handle(struct srpc_server_rpc *rpc)
 419 {
 420         struct srpc_service     *sv = rpc->srpc_scd->scd_svc;
 421         srpc_msg_t       *replymsg = &rpc->srpc_replymsg;
 422         srpc_msg_t       *reqstmsg = &rpc->srpc_reqstbuf->buf_msg;
 423         srpc_brw_reply_t *reply = &replymsg->msg_body.brw_reply;
 424         srpc_brw_reqst_t *reqst = &reqstmsg->msg_body.brw_reqst;
 425         int               npg;
 426         int            rc;
 427
 428         LASSERT(sv->sv_id == SRPC_SERVICE_BRW);
 429
 430         if (reqstmsg->msg_magic != SRPC_MSG_MAGIC) {
 431                 LASSERT(reqstmsg->msg_magic == __swab32(SRPC_MSG_MAGIC));
 432
 433                 __swab32s(&reqst->brw_rw);
 434                 __swab32s(&reqst->brw_len);
 435                 __swab32s(&reqst->brw_flags);
 436                 __swab64s(&reqst->brw_rpyid);
 437                 __swab64s(&reqst->brw_bulkid);
 438         }
 439         LASSERT(reqstmsg->msg_type == (__u32)srpc_service2request(sv->sv_id));
 440
 441         reply->brw_status = 0;
 442         rpc->srpc_done = brw_server_rpc_done;
 443
 444         if ((reqst->brw_rw != LST_BRW_READ && reqst->brw_rw != LST_BRW_WRITE) ||
 445             (reqst->brw_flags != LST_BRW_CHECK_NONE &&
 446              reqst->brw_flags != LST_BRW_CHECK_FULL &&
 447              reqst->brw_flags != LST_BRW_CHECK_SIMPLE)) {
 448                 reply->brw_status = EINVAL;
 449                 return 0;
 450         }
 451
 452         if ((reqstmsg->msg_ses_feats & ~LST_FEATS_MASK) != 0) {
 453                 replymsg->msg_ses_feats = LST_FEATS_MASK;
 454                 reply->brw_status = EPROTO;
 455                 return 0;
 456         }
 457
 458         if ((reqstmsg->msg_ses_feats & LST_FEAT_BULK_LEN) == 0) {
 459                 /* compat with old version */
 460                 if ((reqst->brw_len & ~CFS_PAGE_MASK) != 0) {
 461                         reply->brw_status = EINVAL;
 462                         return 0;
 463                 }
 464                 npg = reqst->brw_len >> PAGE_CACHE_SHIFT;
 465
 466         } else {
 467                 npg = (reqst->brw_len + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
 468         }
 469
 470         replymsg->msg_ses_feats = reqstmsg->msg_ses_feats;
 471
 472         if (reqst->brw_len == 0 || npg > LNET_MAX_IOV) {
 473                 reply->brw_status = EINVAL;
 474                 return 0;
 475         }
 476
 477         rc = sfw_alloc_pages(rpc, rpc->srpc_scd->scd_cpt, npg,
 478                              reqst->brw_len,
 479                              reqst->brw_rw == LST_BRW_WRITE);
 480         if (rc != 0)
 481                 return rc;
 482
 483         if (reqst->brw_rw == LST_BRW_READ)
 484                 brw_fill_bulk(rpc->srpc_bulk, reqst->brw_flags, BRW_MAGIC);
 485         else
 486                 brw_fill_bulk(rpc->srpc_bulk, reqst->brw_flags, BRW_POISON);
 487
 488         return 0;
 489 }
 490
 491 sfw_test_client_ops_t brw_test_client;
 492 void brw_init_test_client(void)
 493 {
 494         brw_test_client.tso_init       = brw_client_init;
 495         brw_test_client.tso_fini       = brw_client_fini;
 496         brw_test_client.tso_prep_rpc   = brw_client_prep_rpc;
 497         brw_test_client.tso_done_rpc   = brw_client_done_rpc;
 498 };
 499
 500 srpc_service_t brw_test_service;
 501 void brw_init_test_service(void)
 502 {
 503
 504         brw_test_service.sv_id   = SRPC_SERVICE_BRW;
 505         brw_test_service.sv_name       = "brw_test";
 506         brw_test_service.sv_handler    = brw_server_handle;
 507         brw_test_service.sv_bulk_ready = brw_bulk_ready;
 508         brw_test_service.sv_wi_total   = brw_srv_workitems;
 509 }