src/tools/rxperf/rxperf.c

   1 /*
   2  * Copyright (c) 2000 - 2001 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution
  16  *    at such time that OpenAFS documentation is written.
  17  *
  18  * 3. Neither the name of the Institute nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #include <afsconfig.h>
  36
  37 /*
  38 nn * We are using getopt since we want it to be possible to link to
  39  * transarc libs.
  40  */
  41
  42 #include <afsconfig.h>
  43 #include <afs/param.h>
  44 #include <roken.h>
  45
  46 #ifdef HAVE_SYS_FILE_H
  47 #include <sys/file.h>
  48 #endif
  49
  50 #include <assert.h>
  51
  52 #include <rx/rx.h>
  53 #include <rx/rx_null.h>
  54 #include <rx/rx_globals.h>
  55 #include <rx/rx_packet.h>
  56
  57 #ifdef AFS_PTHREAD_ENV
  58 #include <pthread.h>
  59 #define MAX_THREADS 128
  60 #endif
  61
  62 #define DEFAULT_PORT 7009       /* To match tcpdump */
  63 #define DEFAULT_HOST "127.0.0.1"
  64 #define DEFAULT_BYTES 1024 * 1024
  65 #define RXPERF_BUFSIZE 512 * 1024
  66
  67 enum { RX_PERF_VERSION = 3 };
  68 enum { RX_SERVER_ID = 147 };
  69 enum { RX_PERF_UNKNOWN = -1,
  70        RX_PERF_SEND = 0,
  71        RX_PERF_RECV = 1,
  72        RX_PERF_RPC = 3,
  73        RX_PERF_FILE = 4
  74 };
  75
  76 enum { RXPERF_MAGIC_COOKIE = 0x4711 };
  77
  78 /*
  79  *
  80  */
  81
  82 #if RXPERF_DEBUG
  83 #define DBFPRINT(x) do { printf x ; } while(0)
  84 #else
  85 #define DBFPRINT(x)
  86 #endif
  87
  88 static void
  89 sigusr1(int foo)
  90 {
  91     exit(2);                    /* XXX profiler */
  92 }
  93
  94 static void
  95 sigint(int foo)
  96 {
  97     rx_Finalize();
  98     exit(2);                    /* XXX profiler */
  99 }
 100
 101 /*
 102  *
 103  */
 104
 105 static struct timeval timer_start;
 106 static struct timeval timer_stop;
 107 static int timer_check = 0;
 108
 109 static void
 110 start_timer(void)
 111 {
 112     timer_check++;
 113     gettimeofday(&timer_start, NULL);
 114 }
 115
 116 /*
 117  *
 118  */
 119
 120 static void
 121 end_and_print_timer(char *str)
 122 {
 123     long long start_l, stop_l;
 124
 125     timer_check--;
 126     assert(timer_check == 0);
 127     gettimeofday(&timer_stop, NULL);
 128     start_l = timer_start.tv_sec * 1000000 + timer_start.tv_usec;
 129     stop_l = timer_stop.tv_sec * 1000000 + timer_stop.tv_usec;
 130     printf("%s:\t%8llu msec\n", str, (stop_l - start_l) / 1000);
 131 }
 132
 133 /*
 134  *
 135  */
 136
 137 static u_long
 138 str2addr(const char *s)
 139 {
 140     struct in_addr server;
 141     struct hostent *h;
 142
 143 #ifndef INADDR_NONE
 144 #define INADDR_NONE 0xffffffff
 145 #endif
 146     if (inet_addr(s) != INADDR_NONE)
 147         return inet_addr(s);
 148     h = gethostbyname(s);
 149     if (h != NULL) {
 150         memcpy(&server, h->h_addr_list[0], sizeof(server));
 151         return server.s_addr;
 152     }
 153     return 0;
 154 }
 155
 156
 157 /*
 158  *
 159  */
 160
 161 static void
 162 get_sec(int serverp, struct rx_securityClass **sec, int *secureindex)
 163 {
 164     if (serverp) {
 165         *sec = rxnull_NewServerSecurityObject();
 166         *secureindex = 1;
 167     } else {
 168         *sec = rxnull_NewClientSecurityObject();
 169         *secureindex = 0;
 170     }
 171 }
 172
 173 /*
 174  * process the "RPC" and return the results
 175  */
 176
 177 char somebuf[RXPERF_BUFSIZE];
 178
 179 afs_int32 rxwrite_size = sizeof(somebuf);
 180 afs_int32 rxread_size = sizeof(somebuf);
 181 afs_int32 use_rx_readv = 0;
 182
 183 static int
 184 do_readbytes(struct rx_call *call, afs_int32 bytes)
 185 {
 186     struct iovec tiov[RX_MAXIOVECS];
 187     afs_int32 size;
 188     int tnio;
 189     int code;
 190
 191     while (bytes > 0) {
 192         size = rxread_size;
 193
 194         if (size > bytes)
 195             size = bytes;
 196         if (use_rx_readv) {
 197             if (size > RX_MAX_PACKET_DATA_SIZE)
 198                 size = RX_MAX_PACKET_DATA_SIZE;
 199             code = rx_Readv(call, tiov, &tnio, RX_MAXIOVECS, size);
 200         } else
 201             code = rx_Read(call, somebuf, size);
 202         if (code != size)
 203             return 1;
 204
 205         bytes -= size;
 206     }
 207     return 0;
 208 }
 209
 210 static int
 211 do_sendbytes(struct rx_call *call, afs_int32 bytes)
 212 {
 213     afs_int32 size;
 214
 215     while (bytes > 0) {
 216         size = rxwrite_size;
 217         if (size > bytes)
 218             size = bytes;
 219         if (rx_Write(call, somebuf, size) != size)
 220             return 1;
 221         bytes -= size;
 222     }
 223     return 0;
 224 }
 225
 226
 227 static afs_int32
 228 rxperf_ExecuteRequest(struct rx_call *call)
 229 {
 230     afs_int32 version;
 231     afs_int32 command;
 232     afs_int32 bytes;
 233     afs_int32 recvb;
 234     afs_int32 sendb;
 235     afs_int32 data;
 236     afs_uint32 num;
 237     afs_uint32 *readwrite;
 238     afs_uint32 i;
 239     int readp = TRUE;
 240
 241     DBFPRINT(("got a request\n"));
 242
 243     if (rx_Read32(call, &version) != 4) {
 244         warn("rx_Read failed to read version");
 245         return -1;
 246     }
 247
 248     if (htonl(RX_PERF_VERSION) != version) {
 249         warnx("client has wrong version");
 250         return -1;
 251     }
 252
 253     if (rx_Read32(call, &command) != 4) {
 254         warnx("rx_Read failed to read command");
 255         return -1;
 256     }
 257     command = ntohl(command);
 258
 259     if (rx_Read32(call, &data) != 4) {
 260         warnx("rx_Read failed to read size");
 261         return -1;
 262     }
 263     rxread_size = ntohl(data);
 264     if (rxread_size > sizeof(somebuf)) {
 265         warnx("rxread_size too large %d", rxread_size);
 266         return -1;
 267     }
 268
 269     if (rx_Read32(call, &data) != 4) {
 270         warnx("rx_Read failed to write size");
 271         return -1;
 272     }
 273     rxwrite_size = ntohl(data);
 274     if (rxwrite_size > sizeof(somebuf)) {
 275         warnx("rxwrite_size too large %d", rxwrite_size);
 276         return -1;
 277     }
 278
 279     switch (command) {
 280     case RX_PERF_SEND:
 281         DBFPRINT(("got a send request\n"));
 282
 283         if (rx_Read32(call, &bytes) != 4) {
 284             warnx("rx_Read failed to read bytes");
 285             return -1;
 286         }
 287         bytes = ntohl(bytes);
 288
 289         DBFPRINT(("reading(%d) ", bytes));
 290         do_readbytes(call, bytes);
 291
 292         data = htonl(RXPERF_MAGIC_COOKIE);
 293         if (rx_Write32(call, &data) != 4) {
 294             warnx("rx_Write failed when sending back result");
 295             return -1;
 296         }
 297         DBFPRINT(("done\n"));
 298
 299         break;
 300     case RX_PERF_RPC:
 301         DBFPRINT(("got a rpc request, reading commands\n"));
 302
 303         if (rx_Read32(call, &recvb) != 4) {
 304             warnx("rx_Read failed to read recvbytes");
 305             return -1;
 306         }
 307         recvb = ntohl(recvb);
 308         if (rx_Read32(call, &sendb) != 4) {
 309             warnx("rx_Read failed to read sendbytes");
 310             return -1;
 311         }
 312         sendb = ntohl(sendb);
 313
 314         DBFPRINT(("read(%d) ", recvb));
 315         if (do_readbytes(call, recvb)) {
 316             warnx("do_readbytes failed");
 317             return -1;
 318         }
 319         DBFPRINT(("send(%d) ", sendb));
 320         if (do_sendbytes(call, sendb)) {
 321             warnx("sendbytes failed");
 322             return -1;
 323         }
 324
 325         DBFPRINT(("done\n"));
 326
 327         data = htonl(RXPERF_MAGIC_COOKIE);
 328         if (rx_Write32(call, &data) != 4) {
 329             warnx("rx_Write failed when sending back magic cookie");
 330             return -1;
 331         }
 332
 333         break;
 334     case RX_PERF_FILE:
 335         if (rx_Read32(call, &data) != 4)
 336             errx(1, "failed to read num from client");
 337         num = ntohl(data);
 338
 339         readwrite = malloc(num * sizeof(afs_uint32));
 340         if (readwrite == NULL)
 341             err(1, "malloc");
 342
 343         if (rx_Read(call, (char*)readwrite, num * sizeof(afs_uint32)) !=
 344             num * sizeof(afs_uint32))
 345             errx(1, "failed to read recvlist from client");
 346
 347         for (i = 0; i < num; i++) {
 348             if (readwrite[i] == 0) {
 349                 DBFPRINT(("readp %d", readwrite[i]));
 350                 readp = !readp;
 351             }
 352
 353             bytes = ntohl(readwrite[i]) * sizeof(afs_uint32);
 354
 355             if (readp) {
 356                 DBFPRINT(("read\n"));
 357                 do_readbytes(call, bytes);
 358             } else {
 359                 do_sendbytes(call, bytes);
 360                 DBFPRINT(("send\n"));
 361             }
 362         }
 363
 364         break;
 365     case RX_PERF_RECV:
 366         DBFPRINT(("got a recv request\n"));
 367
 368         if (rx_Read32(call, &bytes) != 4) {
 369             warnx("rx_Read failed to read bytes");
 370             return -1;
 371         }
 372         bytes = ntohl(bytes);
 373
 374         DBFPRINT(("sending(%d) ", bytes));
 375         do_sendbytes(call, bytes);
 376
 377         data = htonl(RXPERF_MAGIC_COOKIE);
 378         if (rx_Write32(call, &data) != 4) {
 379             warnx("rx_Write failed when sending back result");
 380             return -1;
 381         }
 382         DBFPRINT(("done\n"));
 383
 384         break;
 385     default:
 386         warnx("client sent a unsupported command");
 387         return -1;
 388     }
 389     DBFPRINT(("done with command\n"));
 390
 391     return 0;
 392 }
 393
 394 /*
 395  *
 396  */
 397
 398 static void
 399 do_server(short port, int nojumbo, int maxmtu, int maxwsize, int minpeertimeout,
 400           int udpbufsz, int nostats, int hotthread,
 401           int minprocs, int maxprocs)
 402 {
 403     struct rx_service *service;
 404     struct rx_securityClass *secureobj;
 405     int secureindex;
 406     int ret;
 407
 408 #ifdef AFS_NT40_ENV
 409     if (afs_winsockInit() < 0) {
 410         printf("Can't initialize winsock.\n");
 411         exit(1);
 412     }
 413 #endif
 414
 415     if (hotthread)
 416         rx_EnableHotThread();
 417
 418     if (nostats)
 419         rx_enable_stats = 0;
 420
 421     rx_SetUdpBufSize(udpbufsz);
 422
 423     ret = rx_Init(htons(port));
 424     if (ret)
 425         errx(1, "rx_Init failed");
 426
 427     if (nojumbo)
 428       rx_SetNoJumbo();
 429
 430     if (maxmtu)
 431       rx_SetMaxMTU(maxmtu);
 432
 433     if (maxwsize) {
 434         rx_SetMaxReceiveWindow(maxwsize);
 435         rx_SetMaxSendWindow(maxwsize);
 436     }
 437
 438     if (minpeertimeout)
 439         rx_SetMinPeerTimeout(minpeertimeout);
 440
 441
 442     get_sec(1, &secureobj, &secureindex);
 443
 444     service =
 445         rx_NewService(0, RX_SERVER_ID, "rxperf", &secureobj, secureindex,
 446                       rxperf_ExecuteRequest);
 447     if (service == NULL)
 448         errx(1, "Cant create server");
 449
 450     rx_SetMinProcs(service, minprocs);
 451     rx_SetMaxProcs(service, maxprocs);
 452
 453     rx_SetCheckReach(service, 1);
 454
 455     rx_StartServer(1);
 456
 457     abort();
 458 }
 459
 460 /*
 461  *
 462  */
 463
 464 static void
 465 readfile(const char *filename, afs_uint32 ** readwrite, afs_uint32 * size)
 466 {
 467     FILE *f;
 468     afs_uint32 len = 16;
 469     afs_uint32 num = 0;
 470     afs_uint32 data;
 471     char *ptr;
 472     char *buf;
 473
 474     *readwrite = malloc(sizeof(afs_uint32) * len);
 475     buf = malloc(RXPERF_BUFSIZE);
 476
 477     if (*readwrite == NULL)
 478         err(1, "malloc");
 479
 480     f = fopen(filename, "r");
 481     if (f == NULL)
 482         err(1, "fopen");
 483
 484     while (fgets(buf, sizeof(buf), f) != NULL) {
 485         if (num >= len) {
 486             len = len * 2;
 487             *readwrite = realloc(*readwrite, len * sizeof(afs_uint32));
 488             if (*readwrite == NULL)
 489                 err(1, "realloc");
 490         }
 491
 492         if (*buf != '\n') {
 493             data = htonl(strtol(buf, &ptr, 0));
 494             if (ptr && ptr == buf)
 495                 errx(1, "can't resolve number of bytes to transfer");
 496         } else {
 497             data = 0;
 498         }
 499
 500         (*readwrite)[num] = data;
 501         num++;
 502     }
 503
 504     *size = num;
 505
 506
 507     if (fclose(f) == -1)
 508         err(1, "fclose");
 509     free(buf);
 510 }
 511
 512 struct client_data {
 513     struct rx_connection *conn;
 514     char *filename;
 515     int command;
 516     afs_int32 times;
 517     afs_int32 bytes;
 518     afs_int32 sendbytes;
 519     afs_int32 readbytes;
 520 };
 521
 522 static void *
 523 client_thread( void *vparams)
 524 {
 525     struct client_data *params = (struct client_data *)vparams;
 526     struct rx_call *call;
 527     afs_int32 data;
 528     int i, j;
 529     afs_uint32 *readwrite;
 530     int readp = FALSE;
 531     afs_uint32 size;
 532     afs_uint32 num;
 533
 534     for (i = 0; i < params->times; i++) {
 535
 536         DBFPRINT(("starting command "));
 537
 538         call = rx_NewCall(params->conn);
 539         if (call == NULL)
 540             errx(1, "rx_NewCall failed");
 541
 542         data = htonl(RX_PERF_VERSION);
 543         if (rx_Write32(call, &data) != 4)
 544             errx(1, "rx_Write failed to send version (err %d)", rx_Error(call));
 545
 546         data = htonl(params->command);
 547         if (rx_Write32(call, &data) != 4)
 548             errx(1, "rx_Write failed to send command (err %d)", rx_Error(call));
 549
 550         data = htonl(rxread_size);
 551         if (rx_Write32(call, &data) != 4)
 552             errx(1, "rx_Write failed to send read size (err %d)", rx_Error(call));
 553         data = htonl(rxwrite_size);
 554         if (rx_Write32(call, &data) != 4)
 555             errx(1, "rx_Write failed to send write read (err %d)", rx_Error(call));
 556
 557
 558         switch (params->command) {
 559         case RX_PERF_RECV:
 560             DBFPRINT(("command "));
 561
 562             data = htonl(params->bytes);
 563             if (rx_Write32(call, &data) != 4)
 564                 errx(1, "rx_Write failed to send size (err %d)", rx_Error(call));
 565
 566             DBFPRINT(("sending(%d) ", params->bytes));
 567             if (do_readbytes(call, params->bytes))
 568                 errx(1, "sendbytes (err %d)", rx_Error(call));
 569
 570             if (rx_Read32(call, &data) != 4)
 571                 errx(1, "failed to read result from server (err %d)", rx_Error(call));
 572
 573             if (data != htonl(RXPERF_MAGIC_COOKIE))
 574                 warn("server send wrong magic cookie in responce");
 575
 576             DBFPRINT(("done\n"));
 577
 578             break;
 579         case RX_PERF_SEND:
 580             DBFPRINT(("command "));
 581
 582             data = htonl(params->bytes);
 583             if (rx_Write32(call, &data) != 4)
 584                 errx(1, "rx_Write failed to send size (err %d)", rx_Error(call));
 585
 586             DBFPRINT(("sending(%d) ", params->bytes));
 587             if (do_sendbytes(call, params->bytes))
 588                 errx(1, "sendbytes (err %d)", rx_Error(call));
 589
 590             if (rx_Read32(call, &data) != 4)
 591                 errx(1, "failed to read result from server (err %d)", rx_Error(call));
 592
 593             if (data != htonl(RXPERF_MAGIC_COOKIE))
 594                 warn("server send wrong magic cookie in responce");
 595
 596             DBFPRINT(("done\n"));
 597
 598             break;
 599         case RX_PERF_RPC:
 600             DBFPRINT(("commands "));
 601
 602             data = htonl(params->sendbytes);
 603             if (rx_Write32(call, &data) != 4)
 604                 errx(1, "rx_Write failed to send command (err %d)", rx_Error(call));
 605
 606             data = htonl(params->readbytes);
 607             if (rx_Write32(call, &data) != 4)
 608                 errx(1, "rx_Write failed to send command (err %d)", rx_Error(call));
 609
 610             DBFPRINT(("send(%d) ", params->sendbytes));
 611             if (do_sendbytes(call, params->sendbytes))
 612                 errx(1, "sendbytes (err %d)", rx_Error(call));
 613
 614             DBFPRINT(("recv(%d) ", params->readbytes));
 615             if (do_readbytes(call, params->readbytes))
 616                 errx(1, "sendbytes (err %d)", rx_Error(call));
 617
 618             if (rx_Read32(call, &data) != 4)
 619                 errx(1, "failed to read result from server (err %d)", rx_Error(call));
 620
 621             if (data != htonl(RXPERF_MAGIC_COOKIE))
 622                 warn("server send wrong magic cookie in responce");
 623
 624             DBFPRINT(("done\n"));
 625
 626             break;
 627
 628         case RX_PERF_FILE:
 629             readfile(params->filename, &readwrite, &num);
 630
 631             data = htonl(num);
 632             if (rx_Write32(call, &data) != 4)
 633                 errx(1, "rx_Write failed to send size (err %d)", rx_Error(call));
 634
 635             if (rx_Write(call, (char *)readwrite, num * sizeof(afs_uint32))
 636                 != num * sizeof(afs_uint32))
 637                 errx(1, "rx_Write failed to send list (err %d)", rx_Error(call));
 638
 639             for (j = 0; j < num; j++) {
 640                 if (readwrite[j] == 0)
 641                     readp = !readp;
 642
 643                 size = ntohl(readwrite[j]) * sizeof(afs_uint32);
 644
 645                 if (readp) {
 646                     if (do_readbytes(call, size))
 647                         errx(1, "sendbytes (err %d)", rx_Error(call));
 648                     DBFPRINT(("read\n"));
 649                 } else {
 650                     if (do_sendbytes(call, size))
 651                         errx(1, "sendbytes (err %d)", rx_Error(call));
 652                     DBFPRINT(("send\n"));
 653                 }
 654             }
 655             break;
 656         default:
 657             abort();
 658         }
 659
 660         rx_EndCall(call, 0);
 661     }
 662
 663 #ifdef AFS_PTHREAD_ENV
 664     pthread_exit(NULL);
 665 #endif
 666
 667     return NULL;
 668 }
 669
 670 /*
 671  *
 672  */
 673
 674 static void
 675 do_client(const char *server, short port, char *filename, afs_int32 command,
 676           afs_int32 times, afs_int32 bytes, afs_int32 sendbytes, afs_int32 readbytes,
 677           int dumpstats, int nojumbo, int maxmtu, int maxwsize, int minpeertimeout,
 678           int udpbufsz, int nostats, int hotthread, int threads)
 679 {
 680     struct rx_connection *conn;
 681     afs_uint32 addr;
 682     struct rx_securityClass *secureobj;
 683     int secureindex;
 684     int ret;
 685     char stamp[2048];
 686     struct client_data *params;
 687
 688 #ifdef AFS_PTHREAD_ENV
 689     int i;
 690     pthread_t thread[MAX_THREADS];
 691     pthread_attr_t tattr;
 692     void *status;
 693 #endif
 694
 695     params = calloc(1, sizeof(struct client_data));
 696
 697 #ifdef AFS_NT40_ENV
 698     if (afs_winsockInit() < 0) {
 699         printf("Can't initialize winsock.\n");
 700         exit(1);
 701     }
 702 #endif
 703
 704     if (hotthread)
 705         rx_EnableHotThread();
 706
 707     if (nostats)
 708         rx_enable_stats = 0;
 709
 710     addr = str2addr(server);
 711
 712     rx_SetUdpBufSize(udpbufsz);
 713
 714     ret = rx_Init(0);
 715     if (ret)
 716         errx(1, "rx_Init failed");
 717
 718     if (nojumbo)
 719       rx_SetNoJumbo();
 720
 721     if (maxmtu)
 722       rx_SetMaxMTU(maxmtu);
 723
 724     if (maxwsize) {
 725         rx_SetMaxReceiveWindow(maxwsize);
 726         rx_SetMaxSendWindow(maxwsize);
 727     }
 728
 729     if (minpeertimeout)
 730         rx_SetMinPeerTimeout(minpeertimeout);
 731
 732
 733     get_sec(0, &secureobj, &secureindex);
 734
 735     switch (command) {
 736     case RX_PERF_RPC:
 737         sprintf(stamp, "RPC: threads\t%d, times\t%d, write bytes\t%d, read bytes\t%d",
 738                  threads, times, sendbytes, readbytes);
 739         break;
 740     case RX_PERF_RECV:
 741         sprintf(stamp, "RECV: threads\t%d, times\t%d, bytes\t%d",
 742                  threads, times, bytes);
 743         break;
 744     case RX_PERF_SEND:
 745         sprintf(stamp, "SEND: threads\t%d, times\t%d, bytes\t%d",
 746                  threads, times, bytes);
 747         break;
 748     case RX_PERF_FILE:
 749         sprintf(stamp, "FILE %s: threads\t%d, times\t%d, bytes\t%d",
 750                  filename, threads, times, bytes);
 751         break;
 752     }
 753
 754     conn = rx_NewConnection(addr, htons(port), RX_SERVER_ID, secureobj, secureindex);
 755     if (conn == NULL)
 756         errx(1, "failed to contact server");
 757
 758 #ifdef AFS_PTHREAD_ENV
 759     pthread_attr_init(&tattr);
 760     pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_JOINABLE);
 761 #endif
 762
 763     params->conn = conn;
 764     params->filename = filename;
 765     params->command = command;
 766     params->times = times;
 767     params->bytes = bytes;
 768     params->sendbytes = sendbytes;
 769     params->readbytes = readbytes;
 770
 771     start_timer();
 772
 773 #ifdef AFS_PTHREAD_ENV
 774     for ( i=0; i<threads; i++) {
 775         pthread_create(&thread[i], &tattr, client_thread, params);
 776         if ( (i + 1) % RX_MAXCALLS == 0 ) {
 777             conn = rx_NewConnection(addr, htons(port), RX_SERVER_ID, secureobj, secureindex);
 778             if (conn != NULL) {
 779                 struct client_data *new_params = malloc(sizeof(struct client_data));
 780                 memcpy(new_params, params, sizeof(struct client_data));
 781                 new_params->conn = conn;
 782                 params = new_params;
 783             }
 784         }
 785     }
 786 #else
 787         client_thread(params);
 788 #endif
 789
 790 #ifdef AFS_PTHREAD_ENV
 791     for ( i=0; i<threads; i++)
 792         pthread_join(thread[i], &status);
 793 #endif
 794
 795     end_and_print_timer(stamp);
 796     DBFPRINT(("done for good\n"));
 797
 798     if (dumpstats) {
 799         rx_PrintStats(stdout);
 800         rx_PrintPeerStats(stdout, rx_PeerOf(conn));
 801     }
 802     rx_Finalize();
 803
 804 #ifdef AFS_PTHREAD_ENV
 805     pthread_attr_destroy(&tattr);
 806 #endif
 807
 808     free(params);
 809 }
 810
 811 static void
 812 usage(void)
 813 {
 814 #define COMMON ""
 815
 816     fprintf(stderr, "usage: %s client -c send -b <bytes>\n", getprogname());
 817     fprintf(stderr, "usage: %s client -c recv -b <bytes>\n", getprogname());
 818     fprintf(stderr,
 819             "usage: %s client -c rpc  -S <sendbytes> -R <recvbytes>\n",
 820             getprogname());
 821     fprintf(stderr, "usage: %s client -c file -f filename\n", getprogname());
 822     fprintf(stderr,
 823             "%s: usage: common option to the client "
 824             "-w <write-bytes> -r <read-bytes> -T times -p port -s server -D\n",
 825             getprogname());
 826     fprintf(stderr, "usage: %s server -p port\n", getprogname());
 827 #undef COMMMON
 828     exit(1);
 829 }
 830
 831
 832
 833 /*
 834  * do argument processing and call networking functions
 835  */
 836
 837 static int
 838 rxperf_server(int argc, char **argv)
 839 {
 840     short port = DEFAULT_PORT;
 841     int nojumbo = 0;
 842     int maxmtu = 0;
 843     int nostats = 0;
 844     int udpbufsz = 64 * 1024;
 845     int hotthreads = 0;
 846     int minprocs = 2;
 847     int maxprocs = 20;
 848     int maxwsize = 0;
 849     int minpeertimeout = 0;
 850     char *ptr;
 851     int ch;
 852
 853     while ((ch = getopt(argc, argv, "r:d:p:P:w:W:HNjm:u:4:s:S:V")) != -1) {
 854         switch (ch) {
 855         case 'd':
 856 #ifdef RXDEBUG
 857             rx_debugFile = fopen(optarg, "w");
 858             if (rx_debugFile == NULL)
 859                 err(1, "fopen %s", optarg);
 860 #else
 861             errx(1, "compiled without RXDEBUG");
 862 #endif
 863             break;
 864         case 'r':
 865             rxread_size = strtol(optarg, &ptr, 0);
 866             if (ptr != 0 && ptr[0] != '\0')
 867                 errx(1, "can't resolve readsize");
 868             if (rxread_size > sizeof(somebuf))
 869                 errx(1, "%d > sizeof(somebuf) (%"AFS_SIZET_FMT")", rxread_size,
 870                      sizeof(somebuf));
 871             break;
 872         case 's':
 873             minprocs = strtol(optarg, &ptr, 0);
 874             if (ptr != 0 && ptr[0] != '\0')
 875                 errx(1, "can't resolve minprocs");
 876             break;
 877         case 'S':
 878             maxprocs = strtol(optarg, &ptr, 0);
 879             if (ptr != 0 && ptr[0] != '\0')
 880                 errx(1, "can't resolve maxprocs");
 881             break;
 882         case 'P':
 883             minpeertimeout = strtol(optarg, &ptr, 0);
 884             if (ptr != 0 && ptr[0] != '\0')
 885                 errx(1, "can't resolve min peer timeout");
 886             break;
 887         case 'p':
 888             port = (short) strtol(optarg, &ptr, 0);
 889             if (ptr != 0 && ptr[0] != '\0')
 890                 errx(1, "can't resolve portname");
 891             break;
 892         case 'w':
 893             rxwrite_size = strtol(optarg, &ptr, 0);
 894             if (ptr != 0 && ptr[0] != '\0')
 895                 errx(1, "can't resolve writesize");
 896             if (rxwrite_size > sizeof(somebuf))
 897                 errx(1, "%d > sizeof(somebuf) (%"AFS_SIZET_FMT")", rxwrite_size,
 898                      sizeof(somebuf));
 899             break;
 900         case 'j':
 901           nojumbo=1;
 902           break;
 903         case 'N':
 904           nostats=1;
 905           break;
 906         case 'H':
 907             hotthreads = 1;
 908             break;
 909         case 'm':
 910           maxmtu = strtol(optarg, &ptr, 0);
 911           if (ptr && *ptr != '\0')
 912             errx(1, "can't resolve rx maxmtu to use");
 913             break;
 914         case 'u':
 915             udpbufsz = strtol(optarg, &ptr, 0) * 1024;
 916             if (ptr && *ptr != '\0')
 917                 errx(1, "can't resolve upd buffer size (Kbytes)");
 918             break;
 919         case 'V':
 920             use_rx_readv = 1;
 921             break;
 922         case 'W':
 923             maxwsize = strtol(optarg, &ptr, 0);
 924             if (ptr && *ptr != '\0')
 925                 errx(1, "can't resolve max send/recv window size (packets)");
 926             break;
 927         case '4':
 928           RX_IPUDP_SIZE = 28;
 929           break;
 930         default:
 931             usage();
 932         }
 933     }
 934
 935     if (optind != argc)
 936         usage();
 937
 938     do_server(port, nojumbo, maxmtu, maxwsize, minpeertimeout, udpbufsz,
 939               nostats, hotthreads, minprocs, maxprocs);
 940
 941     return 0;
 942 }
 943
 944 /*
 945  * do argument processing and call networking functions
 946  */
 947
 948 static int
 949 rxperf_client(int argc, char **argv)
 950 {
 951     char *host = DEFAULT_HOST;
 952     int bytes = DEFAULT_BYTES;
 953     short port = DEFAULT_PORT;
 954     char *filename = NULL;
 955     afs_int32 cmd;
 956     int sendbytes = 3;
 957     int readbytes = 30;
 958     int times = 100;
 959     int dumpstats = 0;
 960     int nojumbo = 0;
 961     int nostats = 0;
 962     int maxmtu = 0;
 963     int hotthreads = 0;
 964     int threads = 1;
 965     int udpbufsz = 64 * 1024;
 966     int maxwsize = 0;
 967     int minpeertimeout = 0;
 968     char *ptr;
 969     int ch;
 970
 971     cmd = RX_PERF_UNKNOWN;
 972
 973     while ((ch = getopt(argc, argv, "T:S:R:b:c:d:p:P:r:s:w:W:f:HDNjm:u:4:t:V")) != -1) {
 974         switch (ch) {
 975         case 'b':
 976             bytes = strtol(optarg, &ptr, 0);
 977             if (ptr && *ptr != '\0')
 978                 errx(1, "can't resolve number of bytes to transfer");
 979             break;
 980         case 'c':
 981             if (strcasecmp(optarg, "send") == 0)
 982                 cmd = RX_PERF_SEND;
 983             else if (strcasecmp(optarg, "recv") == 0)
 984                 cmd = RX_PERF_RECV;
 985             else if (strcasecmp(optarg, "rpc") == 0)
 986                 cmd = RX_PERF_RPC;
 987             else if (strcasecmp(optarg, "file") == 0)
 988                 cmd = RX_PERF_FILE;
 989             else
 990                 errx(1, "unknown command %s", optarg);
 991             break;
 992         case 'd':
 993 #ifdef RXDEBUG
 994             rx_debugFile = fopen(optarg, "w");
 995             if (rx_debugFile == NULL)
 996                 err(1, "fopen %s", optarg);
 997 #else
 998             errx(1, "compiled without RXDEBUG");
 999 #endif
1000             break;
1001         case 'P':
1002             minpeertimeout = strtol(optarg, &ptr, 0);
1003             if (ptr != 0 && ptr[0] != '\0')
1004                 errx(1, "can't resolve min peer timeout");
1005             break;
1006         case 'p':
1007             port = (short) strtol(optarg, &ptr, 0);
1008             if (ptr != 0 && ptr[0] != '\0')
1009                 errx(1, "can't resolve portname");
1010             break;
1011         case 'r':
1012             rxread_size = strtol(optarg, &ptr, 0);
1013             if (ptr != 0 && ptr[0] != '\0')
1014                 errx(1, "can't resolve readsize");
1015             if (rxread_size > sizeof(somebuf))
1016                 errx(1, "%d > sizeof(somebuf) (%"AFS_SIZET_FMT")", rxread_size,
1017                      sizeof(somebuf));
1018             break;
1019         case 's':
1020             host = strdup(optarg);
1021             if (host == NULL)
1022                 err(1, "strdup");
1023             break;
1024         case 'V':
1025             use_rx_readv = 1;
1026             break;
1027         case 'w':
1028             rxwrite_size = strtol(optarg, &ptr, 0);
1029             if (ptr != 0 && ptr[0] != '\0')
1030                 errx(1, "can't resolve writesize");
1031             if (rxwrite_size > sizeof(somebuf))
1032                 errx(1, "%d > sizeof(somebuf) (%"AFS_SIZET_FMT")", rxwrite_size,
1033                      sizeof(somebuf));
1034             break;
1035         case 'W':
1036             maxwsize = strtol(optarg, &ptr, 0);
1037             if (ptr && *ptr != '\0')
1038                 errx(1, "can't resolve max send/recv window size (packets)");
1039             break;
1040         case 'T':
1041             times = strtol(optarg, &ptr, 0);
1042             if (ptr && *ptr != '\0')
1043                 errx(1, "can't resolve number of times to execute rpc");
1044             break;
1045         case 'S':
1046             sendbytes = strtol(optarg, &ptr, 0);
1047             if (ptr && *ptr != '\0')
1048                 errx(1, "can't resolve number of bytes to send");
1049             break;
1050         case 'R':
1051             readbytes = strtol(optarg, &ptr, 0);
1052             if (ptr && *ptr != '\0')
1053                 errx(1, "can't resolve number of bytes to receive");
1054             break;
1055         case 't':
1056 #ifdef AFS_PTHREAD_ENV
1057             threads = strtol(optarg, &ptr, 0);
1058             if (ptr && *ptr != '\0')
1059                 errx(1, "can't resolve number of threads to execute");
1060             if (threads > MAX_THREADS)
1061                 errx(1, "too many threads");
1062 #else
1063             errx(1, "Not built for pthreads");
1064 #endif
1065             break;
1066         case 'f':
1067             filename = optarg;
1068             break;
1069         case 'D':
1070             dumpstats = 1;
1071             break;
1072         case 'N':
1073             nostats = 1;
1074             break;
1075         case 'H':
1076             hotthreads = 1;
1077             break;
1078         case 'j':
1079           nojumbo=1;
1080           break;
1081         case 'm':
1082           maxmtu = strtol(optarg, &ptr, 0);
1083           if (ptr && *ptr != '\0')
1084             errx(1, "can't resolve rx maxmtu to use");
1085             break;
1086         case 'u':
1087             udpbufsz = strtol(optarg, &ptr, 0) * 1024;
1088             if (ptr && *ptr != '\0')
1089                 errx(1, "can't resolve upd buffer size (Kbytes)");
1090             break;
1091         case '4':
1092           RX_IPUDP_SIZE = 28;
1093           break;
1094         default:
1095             usage();
1096         }
1097     }
1098
1099     if (nostats && dumpstats)
1100         errx(1, "cannot set both -N and -D");
1101
1102     if (threads > 1 && cmd == RX_PERF_FILE)
1103         errx(1, "cannot use multiple threads with file command");
1104
1105     if (optind != argc)
1106         usage();
1107
1108     if (cmd == RX_PERF_UNKNOWN)
1109         errx(1, "no command given to the client");
1110
1111     do_client(host, port, filename, cmd, times, bytes, sendbytes,
1112               readbytes, dumpstats, nojumbo, maxmtu, maxwsize, minpeertimeout,
1113               udpbufsz, nostats, hotthreads, threads);
1114
1115     return 0;
1116 }
1117
1118 /*
1119  * setup world and call cmd
1120  */
1121
1122 int
1123 main(int argc, char **argv)
1124 {
1125 #ifndef AFS_PTHREAD_ENV
1126     PROCESS pid;
1127 #endif
1128
1129     setprogname(argv[0]);
1130
1131 #ifndef AFS_NT40_ENV
1132     signal(SIGUSR1, sigusr1);
1133     signal(SIGINT, sigint);
1134 #endif
1135
1136 #ifndef AFS_PTHREAD_ENV
1137     LWP_InitializeProcessSupport(LWP_NORMAL_PRIORITY, &pid);
1138 #endif
1139
1140     memset(somebuf, 0, sizeof(somebuf));
1141
1142     if (argc >= 2 && strcmp(argv[1], "server") == 0)
1143         rxperf_server(argc - 1, argv + 1);
1144     else if (argc >= 2 && strcmp(argv[1], "client") == 0)
1145         rxperf_client(argc - 1, argv + 1);
1146     else
1147         usage();
1148     return 0;
1149 }