lustre/utils/loadgen.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * GPL HEADER START
   5  *
   6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 only,
  10  * as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License version 2 for more details (a copy is included
  16  * in the LICENSE file that accompanied this code).
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * version 2 along with this program; If not, see
  20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  21  *
  22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  23  * CA 95054 USA or visit www.sun.com if you need additional information or
  24  * have any questions.
  25  *
  26  * GPL HEADER END
  27  */
  28 /*
  29  * Copyright  2008 Sun Microsystems, Inc. All rights reserved
  30  * Use is subject to license terms.
  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/utils/loadgen.c
  37  *
  38  * See how many local OSCs we can start whaling on a OST
  39  * We're doing direct ioctls instead of going though a system() call to lctl
  40  * to avoid the bash overhead.
  41  * Adds an osc / echo client pair in each thread and starts echo transactions.
  42  *
  43  * Author: Nathan Rutman <nathan@clusterfs.com>
  44  */
  45
  46 #include <pthread.h>
  47 #include <stdlib.h>
  48 #include <stdio.h>
  49 #include <unistd.h>
  50 #include <sys/types.h>
  51 #include <sys/stat.h>
  52 #include <signal.h>
  53 #include <fcntl.h>
  54 #include <errno.h>
  55 #include <string.h>
  56 #include <sys/wait.h>
  57 #include <time.h>
  58 #include <sys/time.h>
  59
  60 #include <lnet/lnetctl.h>
  61 #include <libcfs/libcfsutil.h>
  62 #include "obdctl.h"
  63
  64 static char cmdname[512];
  65 static char target[64] = "";
  66 char nid[64] = "";
  67 static int sig_received = 0;
  68 static int o_verbose = 4; /* 0-5 */
  69 static int my_oss = 0;
  70 static int my_ecs = 0;
  71
  72 static int jt_quit(int argc, char **argv) {
  73         Parser_quit(argc, argv);
  74         return 0;
  75 }
  76
  77 static int loadgen_usage(int argc, char **argv)
  78 {
  79         if (argc == 1) {
  80                 fprintf(stderr,
  81         "This is a test program used to simulate large numbers of\n"
  82         "clients.  The echo obds are used, so the obdecho module must\n"
  83         "be loaded.\n"
  84         "Typical usage would be:\n"
  85         "  loadgen> dev lustre-OST0000       set the target device\n"
  86         "  loadgen> start 20                 start 20 echo clients\n"
  87         "  loadgen> wr 10 5                  have 10 clients do the brw_write\n"
  88         "                                      test 5 times each\n"
  89                         );
  90         }
  91         return (Parser_help(argc, argv));
  92 }
  93
  94 static int loadgen_verbose(int argc, char **argv);
  95 static int loadgen_target(int argc, char **argv);
  96 static int loadgen_start_echosrv(int argc, char **argv);
  97 static int loadgen_start_clients(int argc, char **argv);
  98 static int loadgen_wait(int argc, char **argv);
  99 static int loadgen_write(int argc, char **argv);
 100
 101 command_t cmdlist[] = {
 102         {"device", loadgen_target, 0,
 103          "set target ost name (e.g. lustre-OST0000)\n"
 104          "usage: device <name> [<nid>]"},
 105         {"dl", jt_obd_list, 0, "show all devices\n"
 106          "usage: dl"},
 107         {"echosrv", loadgen_start_echosrv, 0, "start an echo server\n"},
 108         {"start", loadgen_start_clients, 0, "set up echo clients\n"
 109          "usage: start_clients <num>"},
 110         {"verbose", loadgen_verbose, 0, "set verbosity level 0-5\n"
 111          "usage: verbose <level>"},
 112         {"wait", loadgen_wait, 0,
 113          "wait for all threads to finish\n"},
 114         {"write", loadgen_write, 0,
 115          "start a test_brw write test on X clients for Y iterations\n"
 116          "usage: write <num_clients> <num_iter> [<delay>]"},
 117
 118         /* User interface commands */
 119         {"help", loadgen_usage, 0, "help"},
 120         {"exit", jt_quit, 0, "quit"},
 121         {"quit", jt_quit, 0, "quit"},
 122         { 0, 0, 0, NULL }
 123 };
 124
 125
 126 /* Command flags */
 127 #define C_STOP           0x0001
 128 #define C_CREATE_EVERY   0x0002  /* destroy and recreate every time */
 129 #define C_READ           0x0004
 130 #define C_WRITE          0x0008
 131
 132 struct command_t {
 133         int           c_flags;
 134         int           c_rpt;
 135         int           c_delay;
 136 };
 137
 138 struct kid_t {
 139         struct command_t k_cmd;
 140         struct kid_t    *k_next;
 141         pthread_t        k_pthread;
 142         __u64            k_objid;
 143         int              k_id;
 144         int              k_dev;
 145 };
 146
 147 static int live_threads = 0;
 148 static struct kid_t *kid_list = NULL;
 149 pthread_mutex_t m_list = PTHREAD_MUTEX_INITIALIZER;
 150
 151 static struct kid_t *push_kid(int tnum)
 152 {
 153         struct kid_t *kid;
 154         kid = (struct kid_t *)calloc(1, sizeof(struct kid_t));
 155         if (kid == NULL) {
 156                 fprintf(stderr, "malloc failure\n");
 157                 return NULL;
 158         }
 159         kid->k_pthread = pthread_self();
 160         pthread_mutex_lock(&m_list);
 161         kid->k_next = kid_list;
 162         kid->k_id = tnum;
 163         kid_list = kid;
 164         live_threads++;
 165         pthread_mutex_unlock(&m_list);
 166         return kid;
 167 }
 168
 169 int trigger_count = 0;
 170 int waiting_count = 0;
 171 int timer_on = 0;
 172 int all_done = 1;
 173 struct timeval trigger_start;
 174 struct command_t trigger_cmd;
 175 pthread_mutex_t m_trigger = PTHREAD_MUTEX_INITIALIZER;
 176 pthread_cond_t cv_trigger = PTHREAD_COND_INITIALIZER;
 177
 178 unsigned long long write_bytes;
 179 pthread_mutex_t m_count = PTHREAD_MUTEX_INITIALIZER;
 180
 181 static void trigger(int command, int threads, int repeat, int delay)
 182 {
 183
 184         pthread_mutex_lock(&m_trigger);
 185         trigger_cmd.c_flags = command;
 186         trigger_cmd.c_rpt = repeat;
 187         trigger_cmd.c_delay = delay;
 188         trigger_count = threads;
 189         if (o_verbose > 4)
 190                 printf("trigger %d cmd c=%d f=%x\n", trigger_count,
 191                        trigger_cmd.c_rpt, trigger_cmd.c_flags);
 192         gettimeofday(&trigger_start, NULL);
 193         timer_on = 1;
 194         pthread_mutex_lock(&m_count);
 195         write_bytes = 0;
 196         pthread_mutex_unlock(&m_count);
 197
 198         pthread_cond_broadcast(&cv_trigger);
 199         pthread_mutex_unlock(&m_trigger);
 200 }
 201
 202 static __inline__ void stop_all(int unused)
 203 {
 204         sig_received++;
 205 }
 206
 207 static void kill_kids(void)
 208 {
 209         struct kid_t *tmp = kid_list;
 210
 211         stop_all(SIGINT);
 212         trigger(C_STOP, 0, 0, 0);
 213         while(tmp) {
 214                 pthread_kill(tmp->k_pthread, SIGTERM);
 215                 tmp = tmp->k_next;
 216         }
 217 }
 218
 219 static void sig_master(int unused)
 220 {
 221         stop_all(SIGINT);
 222         //jt_quit(0, NULL);
 223 }
 224
 225 static int wait_for_threads()
 226 {
 227         struct kid_t *tmp = kid_list;
 228         int rc = 0, status;
 229         void *statusp;
 230
 231         printf("waiting for %d children\n", live_threads);
 232
 233         while(tmp) {
 234                 rc = pthread_join(tmp->k_pthread, &statusp);
 235                 status = (long)statusp;
 236                 if (o_verbose > 2)
 237                         printf("%d: joined, rc = %d, status = %d\n",
 238                                tmp->k_id, rc, status);
 239                 kid_list = tmp->k_next;
 240                 free(tmp);
 241                 tmp = kid_list;
 242                 live_threads--;
 243         }
 244
 245         if (o_verbose > 0)
 246                 printf("%s done, rc = %d\n", cmdname, rc);
 247         return rc;
 248 }
 249
 250 static int write_proc(char *proc_path, char *value)
 251 {
 252         int fd, rc;
 253
 254         fd = open(proc_path, O_WRONLY);
 255         if (fd == -1) {
 256                 fprintf(stderr, "open('%s') failed: %s\n",
 257                         proc_path, strerror(errno));
 258                 rc = errno;
 259         } else {
 260                 rc = write(fd, value, strlen(value));
 261                 if (rc < 0) {
 262                         fprintf(stderr, "write('%s') failed: %s\n",
 263                                 proc_path, strerror(errno));
 264                 }
 265                 close(fd);
 266         }
 267         return rc;
 268 }
 269
 270 static int read_proc(char *proc_path,  unsigned long long *value)
 271 {
 272         int fd, rc;
 273         char buf[50];
 274
 275         fd = open(proc_path, O_RDONLY);
 276         if (fd == -1) {
 277                 fprintf(stderr, "open('%s') failed: %s\n",
 278                         proc_path, strerror(errno));
 279                 return (errno);
 280         }
 281
 282         rc = read(fd, buf, sizeof(buf));
 283         close(fd);
 284         if (errno == EOPNOTSUPP) {
 285                 /* probably an echo server */
 286                 return rc;
 287         }
 288         if (rc <= 0) {
 289                 fprintf(stderr, "read('%s') failed: %s (%d)\n",
 290                         proc_path, strerror(errno), errno);
 291                 return rc;
 292         }
 293         *value = strtoull(buf, NULL, 10);
 294         return 0;
 295 }
 296
 297 static int grant_estimate(int thread)
 298 {
 299         unsigned long long avail, grant;
 300         char proc_path[50];
 301         int rc;
 302         static int ran = 0;
 303
 304         /* I don't really care about protecting this with a mutex */
 305         if (ran)
 306                 return 0;
 307
 308         if (o_verbose < 2)
 309                 return 0;
 310
 311         /* Divide /proc/fs/lustre/osc/o_0001/kbytesavail
 312            by /proc/fs/lustre/osc/o_0001/cur_grant_bytes to find max clients */
 313         sprintf(proc_path, "/proc/fs/lustre/osc/o%.5d/kbytesavail", thread);
 314         rc = read_proc(proc_path, &avail);
 315         if (rc)
 316                 return rc;
 317         sprintf(proc_path, "/proc/fs/lustre/osc/o%.5d/cur_grant_bytes", thread);
 318         rc = read_proc(proc_path, &grant);
 319         if (rc)
 320                 return rc;
 321         if (grant == 0) {
 322                 return -EINVAL;
 323         }
 324         printf("Estimate %llu clients before we run out of grant space "
 325                "(%lluK / %llu)\n", (avail << 10)  / grant, avail, grant);
 326         ran++;
 327         return 0;
 328 }
 329
 330 /* We hold a thread mutex around create/cleanup because cur_dev is not
 331    shared-memory safe */
 332 pthread_mutex_t m_config = PTHREAD_MUTEX_INITIALIZER;
 333
 334 static int cleanup(char *obdname, int quiet)
 335 {
 336         char *args[3];
 337         int rc;
 338
 339         pthread_mutex_lock(&m_config);
 340
 341         args[0] = cmdname;
 342         args[1] = obdname;
 343         rc = jt_lcfg_device(2, args);
 344         if (rc && !quiet)
 345                 fprintf(stderr, "%s: can't configure '%s' (%d)\n",
 346                         cmdname, obdname, rc);
 347         args[1] = "force";
 348         rc = jt_obd_cleanup(2, args);
 349         if (rc && !quiet)
 350                 fprintf(stderr, "%s: can't cleanup '%s' (%d)\n",
 351                         cmdname, obdname, rc);
 352         rc = jt_obd_detach(1, args);
 353         if (rc && !quiet)
 354                 fprintf(stderr, "%s: can't detach '%s' (%d)\n",
 355                         cmdname, obdname, rc);
 356
 357         pthread_mutex_unlock(&m_config);
 358         return rc;
 359 }
 360
 361 static int echocli_setup(char *oname, char *ename, int *dev)
 362 {
 363         char *args[5];
 364         char proc_path[50];
 365         int rc;
 366
 367         pthread_mutex_lock(&m_config);
 368
 369         args[0] = cmdname;
 370
 371         /* OSC */
 372         /* attach "osc" oscname oscuuid */
 373         args[1] = "osc";
 374         args[2] = args[3] = oname;
 375         rc = jt_lcfg_attach(4, args);
 376         if (rc) {
 377                 fprintf(stderr, "%s: can't attach osc '%s' (%d)\n",
 378                         cmdname, oname, rc);
 379                 /* Assume we want e.g. an old one cleaned anyhow. */
 380                 goto clean;
 381         }
 382         /* setup ostname "OSS_UUID" */
 383         args[1] = target;
 384         args[2] = "OSS_UUID";
 385         rc = jt_lcfg_setup(3, args);
 386         if (rc) {
 387                 fprintf(stderr, "%s: can't setup osc '%s' (%d)\n",
 388                         cmdname, oname, rc);
 389                 goto clean;
 390         }
 391
 392         /* Large grants cause ENOSPC to be reported, even though
 393            there's space left.  We can reduce the grant size by
 394            minimizing these */
 395         sprintf(proc_path, "/proc/fs/lustre/osc/%s/max_dirty_mb", oname);
 396         rc = write_proc(proc_path, "1");
 397         sprintf(proc_path, "/proc/fs/lustre/osc/%s/max_rpcs_in_flight", oname);
 398         rc = write_proc(proc_path, "1");
 399
 400         /* ECHO CLI */
 401         /* attach "echo_client" echoname echouuid */
 402         args[1] = "echo_client";
 403         args[2] = args[3] = ename;
 404         rc = jt_lcfg_attach(4, args);
 405         if (rc) {
 406                 fprintf(stderr, "%s: can't attach '%s' (%d)\n",
 407                         cmdname, ename, rc);
 408                 if (rc == ENODEV)
 409                         fprintf(stderr, "%s: is the obdecho module loaded?\n",
 410                                 cmdname);
 411                 goto clean;
 412         }
 413         /* setup oscname */
 414         args[1] = oname;
 415         rc = jt_lcfg_setup(2, args);
 416         if (rc) {
 417                 fprintf(stderr, "%s: can't setup '%s' (%d)\n",
 418                         cmdname, ename, rc);
 419                 goto clean;
 420         }
 421
 422         args[1] = ename;
 423         rc = jt_obd_device(2, args);
 424         if (rc) {
 425                 fprintf(stderr, "%s: can't set device '%s' (%d)\n",
 426                         cmdname, ename, rc);
 427                 goto clean;
 428         }
 429
 430         if (!rc)
 431                 *dev = jt_obd_get_device();
 432         pthread_mutex_unlock(&m_config);
 433         return rc;
 434
 435 clean:
 436         pthread_mutex_unlock(&m_config);
 437         cleanup(ename, 1);
 438         cleanup(oname, 1);
 439         return rc;
 440 }
 441
 442 /* We can't use the libptlctl library fns because they are not shared-memory
 443    safe with respect to the ioctl device (cur_dev) */
 444 static int obj_ioctl(int cmd, struct obd_ioctl_data *data, int unpack)
 445 {
 446         char *buf = NULL;
 447         int rc;
 448
 449         //IOC_PACK(cmdname, data);
 450         if (obd_ioctl_pack(data, &buf, sizeof(*data))) {
 451                 fprintf(stderr, "dev %d invalid ioctl\n", data->ioc_dev);
 452                 rc = EINVAL;
 453                 goto out;
 454         }
 455
 456         rc = l_ioctl(OBD_DEV_ID, cmd, buf);
 457
 458         if (unpack) {
 459                 //IOC_UNPACK(argv[0], data);
 460                 if (obd_ioctl_unpack(data, buf, sizeof(*data))) {
 461                         fprintf(stderr, "dev %d invalid reply\n", data->ioc_dev);
 462                         rc = EINVAL;
 463                         goto out;
 464                 }
 465         }
 466
 467 out:
 468         if (buf)
 469                 free(buf);
 470         return rc;
 471 }
 472
 473 /* See jt_obd_create */
 474 static int obj_create(struct kid_t *kid)
 475 {
 476         struct obd_ioctl_data data;
 477         int rc;
 478
 479         memset(&data, 0, sizeof(data));
 480         data.ioc_dev = kid->k_dev;
 481         data.ioc_obdo1.o_mode = 0100644;
 482         data.ioc_obdo1.o_id = 0;
 483         data.ioc_obdo1.o_seq = FID_SEQ_ECHO;
 484         data.ioc_obdo1.o_uid = 0;
 485         data.ioc_obdo1.o_gid = 0;
 486         data.ioc_obdo1.o_valid = OBD_MD_FLTYPE | OBD_MD_FLMODE |
 487                 OBD_MD_FLID | OBD_MD_FLUID | OBD_MD_FLGID;
 488
 489         rc = obj_ioctl(OBD_IOC_CREATE, &data, 1);
 490         if (rc) {
 491                 fprintf(stderr, "%d: create (%d) %s\n",
 492                         kid->k_id, rc, strerror(errno));
 493                 return rc;
 494         }
 495
 496         if (!(data.ioc_obdo1.o_valid & OBD_MD_FLID)) {
 497                 fprintf(stderr, "%d: create oid not valid "LPX64"\n",
 498                         kid->k_id, data.ioc_obdo1.o_valid);
 499                 return rc;
 500         }
 501
 502         kid->k_objid = data.ioc_obdo1.o_id;
 503
 504         if (o_verbose > 4)
 505                 printf("%d: cr "LPX64"\n", kid->k_id, kid->k_objid);
 506
 507         return rc;
 508 }
 509
 510 /* See jt_obd_destroy */
 511 static int obj_delete(struct kid_t *kid)
 512 {
 513         struct obd_ioctl_data data;
 514         int rc;
 515
 516         if (o_verbose > 4)
 517                 printf("%d: del "LPX64"\n", kid->k_id, kid->k_objid);
 518
 519         memset(&data, 0, sizeof(data));
 520         data.ioc_dev = kid->k_dev;
 521         data.ioc_obdo1.o_id = kid->k_objid;
 522         data.ioc_obdo1.o_mode = S_IFREG | 0644;
 523         data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLMODE;
 524
 525         rc = obj_ioctl(OBD_IOC_DESTROY, &data, 1);
 526         if (rc)
 527                 fprintf(stderr, "%s-%d: can't destroy obj "LPX64" (%d)\n",
 528                         cmdname, kid->k_id, kid->k_objid, rc);
 529
 530         kid->k_objid = 0;
 531         return rc;
 532 }
 533
 534 #define difftime(a, b)                                  \
 535         ((a)->tv_sec - (b)->tv_sec +                    \
 536          ((a)->tv_usec - (b)->tv_usec) / 1000000.0)
 537
 538 /* See jt_obd_test_brw */
 539 static int obj_write(struct kid_t *kid)
 540 {
 541         struct obd_ioctl_data data;
 542         struct timeval start;
 543         __u64 count, len;
 544         int rc = 0, i, pages = 0;
 545
 546         if (o_verbose > 4)
 547                 printf("%d: wr "LPX64"\n", kid->k_id, kid->k_objid);
 548
 549         count = 10;
 550         pages = 32;
 551         len = pages * getpagesize();
 552
 553         memset(&data, 0, sizeof(data));
 554         data.ioc_dev = kid->k_dev;
 555         /* communicate the 'type' of brw test and batching to echo_client.
 556          * don't start.  we'd love to refactor this lctl->echo_client
 557          * interface */
 558         data.ioc_pbuf1 = (void *)1;
 559         data.ioc_plen1 = 1;
 560
 561         data.ioc_obdo1.o_id = kid->k_objid;
 562         data.ioc_obdo1.o_mode = S_IFREG;
 563         data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLMODE |
 564                 OBD_MD_FLFLAGS;
 565         data.ioc_obdo1.o_flags = OBD_FL_DEBUG_CHECK;
 566         data.ioc_count = len;
 567         data.ioc_offset = 0;
 568
 569         gettimeofday(&start, NULL);
 570
 571         for (i = 1; i <= count; i++) {
 572                 data.ioc_obdo1.o_valid &= ~(OBD_MD_FLBLOCKS|OBD_MD_FLGRANT);
 573                 rc = obj_ioctl(OBD_IOC_BRW_WRITE, &data, 0);
 574                 if (rc) {
 575                         fprintf(stderr, "%d: write %s\n", kid->k_id,
 576                                 strerror(rc = errno));
 577                         break;
 578                 }
 579
 580                 data.ioc_offset += len;
 581         }
 582
 583         if (!rc) {
 584                 struct timeval end;
 585                 double diff;
 586
 587                 gettimeofday(&end, NULL);
 588                 diff = difftime(&end, &start);
 589
 590                 --i;
 591
 592                 pthread_mutex_lock(&m_count);
 593                 write_bytes += i * len;
 594                 pthread_mutex_unlock(&m_count);
 595
 596                 if (o_verbose > 4)
 597                         printf("%d: wrote %dx%d pages in %.3fs (%.3f MB/s): %s",
 598                                kid->k_id, i, pages, diff,
 599                                ((double)i * len) / (diff * 1048576.0),
 600                                ctime(&end.tv_sec));
 601         }
 602
 603         if (rc)
 604                 fprintf(stderr, "%s-%d: err test_brw obj "LPX64" (%d)\n",
 605                         cmdname, kid->k_id, kid->k_objid, rc);
 606         return rc;
 607 }
 608
 609 static int do_work(struct kid_t *kid)
 610 {
 611         int rc = 0, err, iter = 0;
 612
 613         if (!(kid->k_cmd.c_flags & C_CREATE_EVERY))
 614                 rc = obj_create(kid);
 615
 616         for (iter = 0; iter < kid->k_cmd.c_rpt; iter++) {
 617                 if (rc || sig_received)
 618                         break;
 619
 620                 if (kid->k_cmd.c_flags & C_CREATE_EVERY) {
 621                         rc = obj_create(kid);
 622                         if (rc)
 623                                 break;
 624                 }
 625
 626                 if (kid->k_cmd.c_flags & C_WRITE) {
 627                         rc = obj_write(kid);
 628                         grant_estimate(kid->k_id);
 629                 }
 630
 631                 if (kid->k_cmd.c_flags & C_CREATE_EVERY) {
 632                         err = obj_delete(kid);
 633                         if (!rc) rc = err;
 634                 }
 635
 636                 if ((o_verbose > 3) && (iter % 10 == 0))
 637                         printf("%d: i%d\n", kid->k_id, iter);
 638                 if (!rc)
 639                         sleep(kid->k_cmd.c_delay);
 640         }
 641
 642         if (!(kid->k_cmd.c_flags & C_CREATE_EVERY)) {
 643                 err = obj_delete(kid);
 644                 if (!rc) rc = err;
 645         }
 646
 647         if (o_verbose > 2)
 648                 printf("%d: done (%d)\n", kid->k_id, rc);
 649
 650         return rc;
 651 }
 652
 653 static void report_perf()
 654 {
 655         struct timeval end;
 656         double diff;
 657
 658         gettimeofday(&end, NULL);
 659         diff = difftime(&end, &trigger_start);
 660         if (o_verbose > 2) {
 661                 pthread_mutex_lock(&m_count);
 662                 printf("wrote %lluMB in %.3fs (%.3f MB/s)\n",
 663                        write_bytes >> 20, diff,
 664                        (write_bytes >> 20) / diff);
 665                 pthread_mutex_unlock(&m_count);
 666         }
 667 }
 668
 669 static void *run_one_child(void *threadvp)
 670 {
 671         struct kid_t *kid;
 672         char oname[10], ename[10];
 673         int thread = (long)threadvp, dev = 0;
 674         int rc = 0, err;
 675
 676         if (o_verbose > 2)
 677                 printf("%s: running thread #%d\n", cmdname, thread);
 678
 679         sprintf(oname, "o%.5d", thread);
 680         sprintf(ename, "e%.5d", thread);
 681         rc = echocli_setup(oname, ename, &dev);
 682         if (rc) {
 683                 fprintf(stderr, "%s: can't setup '%s/%s' (%d)\n",
 684                         cmdname, oname, ename, rc);
 685                 pthread_exit((void *)(long)rc);
 686         }
 687
 688         kid = push_kid(thread);
 689         if (!kid) {
 690                 rc = -ENOMEM;
 691                 goto out;
 692         }
 693         kid->k_dev = dev;
 694
 695         while(!(rc || sig_received)) {
 696                 pthread_mutex_lock(&m_trigger);
 697                 pthread_mutex_lock(&m_list);
 698                 waiting_count++;
 699                 if ((waiting_count == live_threads) && timer_on) {
 700                         report_perf();
 701                         timer_on = 0;
 702                         all_done = 1;
 703                 }
 704                 pthread_mutex_unlock(&m_list);
 705                 pthread_cond_wait(&cv_trigger, &m_trigger);
 706                 waiting_count--;
 707                 all_done = 0;
 708
 709                 /* First trigger_count threads will do the work, the rest
 710                    will block again */
 711                 if (trigger_count) {
 712                         if (o_verbose > 4)
 713                                 printf("%d: trigger %d cmd %x\n",
 714                                        kid->k_id, trigger_count,
 715                                        trigger_cmd.c_flags);
 716                         trigger_count--;
 717                         memcpy(&kid->k_cmd, &trigger_cmd, sizeof(trigger_cmd));
 718                         pthread_mutex_unlock(&m_trigger);
 719                         rc = do_work(kid);
 720                 } else {
 721                         pthread_mutex_unlock(&m_trigger);
 722                 }
 723         }
 724
 725         if (o_verbose > 1)
 726                 printf("%s: thread #%d done (%d)\n", cmdname, thread, rc);
 727
 728         if (rc)
 729                 stop_all(SIGINT);
 730
 731 out:
 732         err = cleanup(ename, 0);
 733         if (!rc) rc = err;
 734         err = cleanup(oname, 0);
 735         if (!rc) rc = err;
 736
 737         pthread_exit((void *)(long)rc);
 738 }
 739
 740 /*
 741  * PTHREAD_STACK_MIN is 16K minimal stack for threads. This
 742  * is stack consumed by one thread, which executes NULL procedure.
 743  * We need some more here and 20k stack for one client thread
 744  * is enough to not overflow. In same time it does not consume
 745  * a lot of memory for large number of threads.
 746  *
 747  * 20K virtual clients will only consume 320M + 400M. Still to
 748  * create this number of virtual clients we need to fix 8192
 749  * OBDs limit.
 750  */
 751 #define CLIENT_THREAD_STACK_SIZE (PTHREAD_STACK_MIN + (20 * 1024))
 752
 753 static int loadgen_start_clients(int argc, char **argv)
 754 {
 755         int rc = 0, i, numt;
 756         struct timespec ts = {0, 1000*1000*100}; /* .1 sec */
 757         pthread_attr_t attr;
 758
 759         if (argc != 2)
 760                 return CMD_HELP;
 761
 762         numt = strtoul(argv[1], NULL, 0);
 763         if (numt < 1)
 764                 return CMD_HELP;
 765
 766         if (!target[0]) {
 767                 fprintf(stderr, "%s: target OST is not defined, use 'device' "
 768                         "command\n", cmdname);
 769                 return -EINVAL;
 770         }
 771
 772         rc = pthread_attr_init(&attr);
 773         if (rc) {
 774                 fprintf(stderr, "%s: pthread_attr_init:(%d) %s\n",
 775                         cmdname, rc, strerror(errno));
 776                 return -errno;
 777         }
 778         pthread_attr_setstacksize (&attr, CLIENT_THREAD_STACK_SIZE);
 779         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 780
 781         numt += live_threads;
 782         i = live_threads;
 783         printf("start %d to %d\n", i, numt);
 784         while(!rc && !sig_received && (i < numt)) {
 785                 pthread_t thread;
 786
 787                 i++;
 788                 rc = pthread_create(&thread, &attr, run_one_child,
 789                                     (void *)(long)i);
 790                 if (rc) {
 791                         fprintf(stderr, "%s: pthread: #%d - (%d) %s\n",
 792                                 cmdname, i, rc, strerror(rc));
 793                         break;
 794                 }
 795
 796                 /* give them slightly different start times */
 797                 nanosleep(&ts, NULL);
 798         }
 799
 800         pthread_attr_destroy(&attr);
 801
 802         return -rc;
 803 }
 804
 805 static int loadgen_target(int argc, char **argv)
 806 {
 807         char *args[3];
 808         __u64 nidx = 0;
 809         int rc = 0;
 810
 811         if (argc < 2 || argc > 3)
 812                 return CMD_HELP;
 813
 814         args[0] = cmdname;
 815
 816         if (argc == 3) {
 817                 nidx = libcfs_str2nid(argv[2]);
 818                 if (nidx == LNET_NID_ANY) {
 819                         fprintf(stderr, "%s: invalid nid '%s'\n",
 820                                 cmdname, argv[2]);
 821                         return -EINVAL;
 822                 }
 823         } else {
 824                 /* Local device should be in list */
 825                 args[1] = argv[1];
 826                 rc = jt_obd_device(2, args);
 827                 if (rc) {
 828                         fprintf(stderr, "%s: local device '%s' doesn't "
 829                                 "seem to exist. You must use obdfilter device "
 830                                 "names like 'lustre-OST0000'.  Use 'dl' to "
 831                                 "list all devices.\n",
 832                                 cmdname, argv[1]);
 833                         return -EINVAL;
 834                 }
 835
 836                 /* Use the first local nid */
 837                 args[1] = (char *)(&nidx);
 838                 args[1][0] = 1; /* hack to get back first nid */
 839                 rc = jt_ptl_list_nids(2, args);
 840                 if (rc) {
 841                         fprintf(stderr, "%s: can't get local nid (%d)\n",
 842                                 cmdname, rc);
 843                         return rc;
 844                 }
 845         }
 846         if (strcmp(nid, libcfs_nid2str(nidx)) != 0) {
 847                 /* if new, do an add_uuid */
 848                 sprintf(nid, "%s", libcfs_nid2str(nidx));
 849
 850                 /* Fixme change the uuid for every new one */
 851                 args[1] = "OSS_UUID";
 852                 args[2] = nid;
 853                 rc = jt_lcfg_add_uuid(3, args);
 854                 if (rc) {
 855                         fprintf(stderr, "%s: can't add uuid '%s' (%d)\n",
 856                                 cmdname, args[2], rc);
 857                         return rc;
 858                 }
 859         }
 860
 861         snprintf(target, sizeof(target), "%s", argv[1]);
 862         printf("Target OST name is '%s'\n", target);
 863
 864         return rc;
 865 }
 866
 867 static int loadgen_verbose(int argc, char **argv)
 868 {
 869         if (argc != 2)
 870                 return CMD_HELP;
 871         o_verbose = atoi(argv[1]);
 872         printf("verbosity set to %d\n", o_verbose);
 873         return 0;
 874 }
 875
 876 static int loadgen_write(int argc, char **argv)
 877 {
 878         int threads;
 879
 880         if (argc < 3 || argc > 4)
 881                 return CMD_HELP;
 882         threads = atoi(argv[1]);
 883         pthread_mutex_lock(&m_list);
 884         if (threads > live_threads) {
 885                 pthread_mutex_unlock(&m_list);
 886                 fprintf(stderr, "requested %d threads but only %d are running. "
 887                         "Use 'start' to start some more.\n",
 888                         threads, live_threads);
 889                 return -EOVERFLOW;
 890         } else {
 891                 pthread_mutex_unlock(&m_list);
 892         }
 893         trigger(C_WRITE, threads, atoi(argv[2]),
 894                 (argc == 4) ? atoi(argv[3]) : 0);
 895         return 0;
 896 }
 897
 898 char ecsname[] = "echosrv";
 899 static int loadgen_stop_echosrv(int argc, char **argv)
 900 {
 901         int verbose = (argc != 9);
 902         if (my_oss) {
 903                 char name[]="OSS";
 904                 cleanup(name, verbose);
 905                 my_oss = 0;
 906         }
 907         if (my_ecs || (argc == 9)) {
 908                 cleanup(ecsname, verbose);
 909                 my_ecs = 0;
 910         }
 911         return 0;
 912 }
 913
 914 static int loadgen_start_echosrv(int argc, char **argv)
 915 {
 916         char *args[5];
 917         int rc;
 918
 919         pthread_mutex_lock(&m_config);
 920
 921         args[0] = cmdname;
 922
 923         /* attach obdecho echosrv echosrv_UUID */
 924         args[1] = "obdecho";
 925         args[2] = args[3] = ecsname;
 926         rc = jt_lcfg_attach(4, args);
 927         if (rc) {
 928                 fprintf(stderr, "%s: can't attach echo server (%d)\n",
 929                         cmdname, rc);
 930                 /* Assume we want e.g. an old one cleaned anyhow. */
 931                 goto clean;
 932         }
 933         my_ecs = 1;
 934
 935         /* setup */
 936         rc = jt_lcfg_setup(1, args);
 937         if (rc) {
 938                 fprintf(stderr, "%s: can't setup echo server (%d)\n",
 939                         cmdname, rc);
 940                 goto clean;
 941         }
 942
 943         /* Create an OSS to handle the communications */
 944         /* attach ost OSS OSS_UUID */
 945         args[1] = "ost";
 946         args[2] = args[3] = "OSS";
 947
 948         rc = jt_lcfg_attach(4, args);
 949         if (rc == EEXIST) {
 950                 /* Already set up for somebody else, that's fine. */
 951                 printf("OSS already set up, no problem.\n");
 952                 pthread_mutex_unlock(&m_config);
 953                 return 0;
 954         }
 955         if (rc) {
 956                 fprintf(stderr, "%s: can't attach OSS (%d)\n",
 957                         cmdname, rc);
 958                 goto clean;
 959         }
 960         my_oss = 1;
 961
 962         /* setup */
 963         rc = jt_lcfg_setup(1, args);
 964         if (rc) {
 965                 fprintf(stderr, "%s: can't setup OSS (%d)\n",
 966                         cmdname, rc);
 967                 goto clean;
 968         }
 969
 970         pthread_mutex_unlock(&m_config);
 971         return rc;
 972
 973 clean:
 974         pthread_mutex_unlock(&m_config);
 975         loadgen_stop_echosrv(9, argv);
 976         return rc;
 977 }
 978
 979 static int loadgen_wait(int argc, char **argv)
 980 {
 981         /* Give scripts a chance to start some threads */
 982         sleep(1);
 983         while (!all_done) {
 984                 sleep(1);
 985         }
 986         return 0;
 987 }
 988
 989 static int loadgen_init(int argc, char **argv)
 990 {
 991         char *args[4];
 992         int rc;
 993
 994         sprintf(cmdname, "%s", argv[0]);
 995
 996         signal(SIGTERM, sig_master);
 997         signal(SIGINT, sig_master);
 998
 999         /* Test to make sure obdecho module is loaded */
1000         args[0] = cmdname;
1001         args[1] = "echo_client";
1002         args[2] = args[3] = "ecc_test";
1003         rc = jt_lcfg_attach(4, args);
1004         if (rc) {
1005                 fprintf(stderr, "%s: can't attach echo client (%d)\n",
1006                         cmdname, rc);
1007                 if (rc == ENODEV)
1008                         fprintf(stderr, "%s: is the obdecho module loaded?\n",
1009                                 cmdname);
1010         } else {
1011                 args[1] = args[2];
1012                 jt_obd_detach(1, args);
1013         }
1014
1015         return rc;
1016 }
1017
1018 static int loadgen_exit()
1019 {
1020         int rc;
1021
1022         printf("stopping %d children\n", live_threads);
1023         kill_kids();
1024         rc = wait_for_threads();
1025
1026         loadgen_stop_echosrv(0, NULL);
1027
1028         return rc;
1029 }
1030
1031 /* libptlctl interface */
1032 static int loadgen_main(int argc, char **argv)
1033 {
1034         int rc;
1035
1036         setlinebuf(stdout);
1037         /* without this threaded errors cause segfault */
1038         setlinebuf(stderr);
1039
1040         if ((rc = ptl_initialize(argc, argv)) < 0)
1041                 exit(rc);
1042         if ((rc = obd_initialize(argc, argv)) < 0)
1043                 exit(rc);
1044         if ((rc = dbg_initialize(argc, argv)) < 0)
1045                 exit(rc);
1046
1047         Parser_init("loadgen> ", cmdlist);
1048
1049         rc = loadgen_init(argc, argv);
1050         if (rc)
1051                 goto out;
1052
1053         if (argc > 1) {
1054                 rc = Parser_execarg(argc - 1, argv + 1, cmdlist);
1055         } else {
1056                 rc = Parser_commands();
1057         }
1058
1059         rc = loadgen_exit();
1060
1061 out:
1062         obd_finalize(argc, argv);
1063         return rc < 0 ? -rc : rc;
1064 }
1065
1066 #ifndef LIBLUSTRE_TEST
1067 int main (int argc, char **argv)
1068 {
1069         int rc;
1070         rc = loadgen_main(argc, argv);
1071         pthread_exit((void *)(long)rc);
1072
1073         return rc;
1074 }
1075 #endif