lnet/selftest/ping_test.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * Author: Liang Zhen <liangzhen@clusterfs.com>
   5  *
   6  * This file is part of Lustre, http://www.lustre.org
   7  *
   8  * Test client & Server
   9  */
  10 #include <libcfs/kp30.h>
  11 #include "selftest.h"
  12
  13 #define LST_PING_TEST_MAGIC     0xbabeface
  14
  15 typedef struct {
  16         spinlock_t      pnd_lock;       /* serialize */
  17         int             pnd_counter;    /* sequence counter */
  18         int             pnd_err_count;  /* error count */
  19 } lst_ping_data_t;
  20
  21 static lst_ping_data_t  lst_ping_data;
  22
  23 static int
  24 ping_client_init(sfw_test_instance_t *tsi)
  25 {
  26         spin_lock_init(&lst_ping_data.pnd_lock);
  27         lst_ping_data.pnd_counter   = 0;
  28         lst_ping_data.pnd_err_count = 0;
  29
  30         return 0;
  31 }
  32
  33 static void
  34 ping_client_fini(sfw_test_instance_t *tsi)
  35 {
  36         CWARN("Total ping %d, failed ping: %d\n",
  37               lst_ping_data.pnd_counter, lst_ping_data.pnd_err_count);
  38 }
  39
  40 static int
  41 ping_client_prep_rpc(sfw_test_unit_t *tsu,
  42                      lnet_process_id_t dest, srpc_client_rpc_t **rpc)
  43 {
  44         srpc_ping_reqst_t *req;
  45         struct timeval     tv;
  46         int                rc;
  47
  48         rc = sfw_create_test_rpc(tsu, dest, 0, 0, rpc);
  49         if (rc != 0)
  50                 return rc;
  51
  52         req = &(*rpc)->crpc_reqstmsg.msg_body.ping_reqst;
  53
  54         req->pnr_magic = LST_PING_TEST_MAGIC;
  55
  56         spin_lock(&lst_ping_data.pnd_lock);
  57         req->pnr_seq = lst_ping_data.pnd_counter ++;
  58         spin_unlock(&lst_ping_data.pnd_lock);
  59
  60         cfs_fs_timeval(&tv);
  61         req->pnr_time_sec  = tv.tv_sec;
  62         req->pnr_time_usec = tv.tv_usec;
  63
  64         return rc;
  65 }
  66
  67 static void
  68 ping_client_done_rpc(sfw_test_unit_t *tsu, srpc_client_rpc_t *rpc)
  69 {
  70         srpc_ping_reqst_t *req;
  71         srpc_ping_reply_t *rep;
  72         struct timeval     tv;
  73
  74         req = &rpc->crpc_reqstmsg.msg_body.ping_reqst;
  75         rep = &rpc->crpc_replymsg.msg_body.ping_reply;
  76
  77         if (rpc->crpc_status == 0 &&
  78             rpc->crpc_replymsg.msg_magic != SRPC_MSG_MAGIC) {
  79                 __swab32s(&rep->pnr_seq);
  80                 __swab32s(&rep->pnr_magic);
  81                 __swab32s(&rep->pnr_status);
  82         }
  83
  84         if (rpc->crpc_status != 0) {
  85                 CERROR ("Unable to ping %s (%d): %d\n",
  86                         libcfs_id2str(rpc->crpc_dest),
  87                         req->pnr_seq, rpc->crpc_status);
  88         } else if (rep->pnr_magic != LST_PING_TEST_MAGIC) {
  89                 tsu->tsu_error = -EBADMSG;
  90                 CERROR ("Bad magic %u from %s, %u expected.\n",
  91                         rep->pnr_magic, libcfs_id2str(rpc->crpc_dest),
  92                         LST_PING_TEST_MAGIC);
  93         } else if (rep->pnr_seq != req->pnr_seq) {
  94                 tsu->tsu_error = -EBADMSG;
  95                 CERROR ("Bad seq %u from %s, %u expected.\n",
  96                         rep->pnr_seq, libcfs_id2str(rpc->crpc_dest),
  97                         req->pnr_seq);
  98         }
  99
 100         if (tsu->tsu_error != 0) {
 101                 spin_lock(&lst_ping_data.pnd_lock);
 102                 lst_ping_data.pnd_err_count++;
 103                 spin_unlock(&lst_ping_data.pnd_lock);
 104                 return;
 105         }
 106
 107         cfs_fs_timeval(&tv);
 108         CDEBUG (D_NET, "%d reply in %u usec\n", rep->pnr_seq,
 109                 (unsigned)((tv.tv_sec - (unsigned)req->pnr_time_sec) * 1000000 +
 110                            (tv.tv_usec - req->pnr_time_usec)));
 111         return;
 112 }
 113
 114 static int
 115 ping_server_handle (srpc_server_rpc_t *rpc)
 116 {
 117         srpc_service_t    *sv  = rpc->srpc_service;
 118         srpc_msg_t        *reqstmsg = &rpc->srpc_reqstbuf->buf_msg;
 119         srpc_ping_reqst_t *req = &reqstmsg->msg_body.ping_reqst;
 120         srpc_ping_reply_t *rep = &rpc->srpc_replymsg.msg_body.ping_reply;
 121
 122         LASSERT (sv->sv_id == SRPC_SERVICE_PING);
 123
 124         if (reqstmsg->msg_magic != SRPC_MSG_MAGIC) {
 125                 LASSERT (reqstmsg->msg_magic == __swab32(SRPC_MSG_MAGIC));
 126
 127                 __swab32s(&reqstmsg->msg_type);
 128                 __swab32s(&req->pnr_seq);
 129                 __swab32s(&req->pnr_magic);
 130                 __swab64s(&req->pnr_time_sec);
 131                 __swab64s(&req->pnr_time_usec);
 132         }
 133         LASSERT (reqstmsg->msg_type == srpc_service2request(sv->sv_id));
 134
 135         if (req->pnr_magic != LST_PING_TEST_MAGIC) {
 136                 CERROR ("Unexpect magic %08x from %s\n",
 137                         req->pnr_magic, libcfs_id2str(rpc->srpc_peer));
 138                 return -EINVAL;
 139         }
 140
 141         rep->pnr_seq   = req->pnr_seq;
 142         rep->pnr_magic = LST_PING_TEST_MAGIC;
 143
 144         CDEBUG (D_NET, "Get ping %d from %s\n",
 145                 req->pnr_seq, libcfs_id2str(rpc->srpc_peer));
 146         return 0;
 147 }
 148
 149 sfw_test_client_ops_t ping_test_client =
 150 {
 151         .tso_init       = ping_client_init,
 152         .tso_fini       = ping_client_fini,
 153         .tso_prep_rpc   = ping_client_prep_rpc,
 154         .tso_done_rpc   = ping_client_done_rpc,
 155 };
 156
 157 srpc_service_t ping_test_service =
 158 {
 159         .sv_name        = "ping test",
 160         .sv_handler     = ping_server_handle,
 161         .sv_id          = SRPC_SERVICE_PING,
 162 };