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 (c) 2007, 2010, Oracle and/or its affiliates. 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 "parser.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_uid = 0;
 484         data.ioc_obdo1.o_gid = 0;
 485         data.ioc_obdo1.o_valid = OBD_MD_FLTYPE | OBD_MD_FLMODE |
 486                 OBD_MD_FLID | OBD_MD_FLUID | OBD_MD_FLGID;
 487
 488         rc = obj_ioctl(OBD_IOC_CREATE, &data, 1);
 489         if (rc) {
 490                 fprintf(stderr, "%d: create (%d) %s\n",
 491                         kid->k_id, rc, strerror(errno));
 492                 return rc;
 493         }
 494
 495         if (!(data.ioc_obdo1.o_valid & OBD_MD_FLID)) {
 496                 fprintf(stderr, "%d: create oid not valid "LPX64"\n",
 497                         kid->k_id, data.ioc_obdo1.o_valid);
 498                 return rc;
 499         }
 500
 501         kid->k_objid = data.ioc_obdo1.o_id;
 502
 503         if (o_verbose > 4)
 504                 printf("%d: cr "LPX64"\n", kid->k_id, kid->k_objid);
 505
 506         return rc;
 507 }
 508
 509 /* See jt_obd_destroy */
 510 static int obj_delete(struct kid_t *kid)
 511 {
 512         struct obd_ioctl_data data;
 513         int rc;
 514
 515         if (o_verbose > 4)
 516                 printf("%d: del "LPX64"\n", kid->k_id, kid->k_objid);
 517
 518         memset(&data, 0, sizeof(data));
 519         data.ioc_dev = kid->k_dev;
 520         data.ioc_obdo1.o_id = kid->k_objid;
 521         data.ioc_obdo1.o_mode = S_IFREG | 0644;
 522         data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLMODE;
 523
 524         rc = obj_ioctl(OBD_IOC_DESTROY, &data, 1);
 525         if (rc)
 526                 fprintf(stderr, "%s-%d: can't destroy obj "LPX64" (%d)\n",
 527                         cmdname, kid->k_id, kid->k_objid, rc);
 528
 529         kid->k_objid = 0;
 530         return rc;
 531 }
 532
 533 #define difftime(a, b)                                  \
 534         ((a)->tv_sec - (b)->tv_sec +                    \
 535          ((a)->tv_usec - (b)->tv_usec) / 1000000.0)
 536
 537 /* See jt_obd_test_brw */
 538 static int obj_write(struct kid_t *kid)
 539 {
 540         struct obd_ioctl_data data;
 541         struct timeval start;
 542         __u64 count, len;
 543         int rc = 0, i, pages = 0;
 544
 545         if (o_verbose > 4)
 546                 printf("%d: wr "LPX64"\n", kid->k_id, kid->k_objid);
 547
 548         count = 10;
 549         pages = 32;
 550         len = pages * getpagesize();
 551
 552         memset(&data, 0, sizeof(data));
 553         data.ioc_dev = kid->k_dev;
 554         /* communicate the 'type' of brw test and batching to echo_client.
 555          * don't start.  we'd love to refactor this lctl->echo_client
 556          * interface */
 557         data.ioc_pbuf1 = (void *)1;
 558         data.ioc_plen1 = 1;
 559
 560         data.ioc_obdo1.o_id = kid->k_objid;
 561         data.ioc_obdo1.o_mode = S_IFREG;
 562         data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLMODE |
 563                 OBD_MD_FLFLAGS;
 564         data.ioc_obdo1.o_flags = OBD_FL_DEBUG_CHECK;
 565         data.ioc_count = len;
 566         data.ioc_offset = 0;
 567
 568         gettimeofday(&start, NULL);
 569
 570         for (i = 1; i <= count; i++) {
 571                 data.ioc_obdo1.o_valid &= ~(OBD_MD_FLBLOCKS|OBD_MD_FLGRANT);
 572                 rc = obj_ioctl(OBD_IOC_BRW_WRITE, &data, 0);
 573                 if (rc) {
 574                         fprintf(stderr, "%d: write %s\n", kid->k_id,
 575                                 strerror(rc = errno));
 576                         break;
 577                 }
 578
 579                 data.ioc_offset += len;
 580         }
 581
 582         if (!rc) {
 583                 struct timeval end;
 584                 double diff;
 585
 586                 gettimeofday(&end, NULL);
 587                 diff = difftime(&end, &start);
 588
 589                 --i;
 590
 591                 pthread_mutex_lock(&m_count);
 592                 write_bytes += i * len;
 593                 pthread_mutex_unlock(&m_count);
 594
 595                 if (o_verbose > 4)
 596                         printf("%d: wrote %dx%d pages in %.3fs (%.3f MB/s): %s",
 597                                kid->k_id, i, pages, diff,
 598                                ((double)i * len) / (diff * 1048576.0),
 599                                ctime(&end.tv_sec));
 600         }
 601
 602         if (rc)
 603                 fprintf(stderr, "%s-%d: err test_brw obj "LPX64" (%d)\n",
 604                         cmdname, kid->k_id, kid->k_objid, rc);
 605         return rc;
 606 }
 607
 608 static int do_work(struct kid_t *kid)
 609 {
 610         int rc = 0, err, iter = 0;
 611
 612         if (!(kid->k_cmd.c_flags & C_CREATE_EVERY))
 613                 rc = obj_create(kid);
 614
 615         for (iter = 0; iter < kid->k_cmd.c_rpt; iter++) {
 616                 if (rc || sig_received)
 617                         break;
 618
 619                 if (kid->k_cmd.c_flags & C_CREATE_EVERY) {
 620                         rc = obj_create(kid);
 621                         if (rc)
 622                                 break;
 623                 }
 624
 625                 if (kid->k_cmd.c_flags & C_WRITE) {
 626                         rc = obj_write(kid);
 627                         grant_estimate(kid->k_id);
 628                 }
 629
 630                 if (kid->k_cmd.c_flags & C_CREATE_EVERY) {
 631                         err = obj_delete(kid);
 632                         if (!rc) rc = err;
 633                 }
 634
 635                 if ((o_verbose > 3) && (iter % 10 == 0))
 636                         printf("%d: i%d\n", kid->k_id, iter);
 637                 if (!rc)
 638                         sleep(kid->k_cmd.c_delay);
 639         }
 640
 641         if (!(kid->k_cmd.c_flags & C_CREATE_EVERY)) {
 642                 err = obj_delete(kid);
 643                 if (!rc) rc = err;
 644         }
 645
 646         if (o_verbose > 2)
 647                 printf("%d: done (%d)\n", kid->k_id, rc);
 648
 649         return rc;
 650 }
 651
 652 static void report_perf()
 653 {
 654         struct timeval end;
 655         double diff;
 656
 657         gettimeofday(&end, NULL);
 658         diff = difftime(&end, &trigger_start);
 659         if (o_verbose > 2) {
 660                 pthread_mutex_lock(&m_count);
 661                 printf("wrote %lluMB in %.3fs (%.3f MB/s)\n",
 662                        write_bytes >> 20, diff,
 663                        (write_bytes >> 20) / diff);
 664                 pthread_mutex_unlock(&m_count);
 665         }
 666 }
 667
 668 static void *run_one_child(void *threadvp)
 669 {
 670         struct kid_t *kid;
 671         char oname[10], ename[10];
 672         int thread = (long)threadvp, dev = 0;
 673         int rc = 0, err;
 674
 675         if (o_verbose > 2)
 676                 printf("%s: running thread #%d\n", cmdname, thread);
 677
 678         sprintf(oname, "o%.5d", thread);
 679         sprintf(ename, "e%.5d", thread);
 680         rc = echocli_setup(oname, ename, &dev);
 681         if (rc) {
 682                 fprintf(stderr, "%s: can't setup '%s/%s' (%d)\n",
 683                         cmdname, oname, ename, rc);
 684                 pthread_exit((void *)(long)rc);
 685         }
 686
 687         kid = push_kid(thread);
 688         if (!kid) {
 689                 rc = -ENOMEM;
 690                 goto out;
 691         }
 692         kid->k_dev = dev;
 693
 694         while(!(rc || sig_received)) {
 695                 pthread_mutex_lock(&m_trigger);
 696                 pthread_mutex_lock(&m_list);
 697                 waiting_count++;
 698                 if ((waiting_count == live_threads) && timer_on) {
 699                         report_perf();
 700                         timer_on = 0;
 701                         all_done = 1;
 702                 }
 703                 pthread_mutex_unlock(&m_list);
 704                 pthread_cond_wait(&cv_trigger, &m_trigger);
 705                 waiting_count--;
 706                 all_done = 0;
 707
 708                 /* First trigger_count threads will do the work, the rest
 709                    will block again */
 710                 if (trigger_count) {
 711                         if (o_verbose > 4)
 712                                 printf("%d: trigger %d cmd %x\n",
 713                                        kid->k_id, trigger_count,
 714                                        trigger_cmd.c_flags);
 715                         trigger_count--;
 716                         memcpy(&kid->k_cmd, &trigger_cmd, sizeof(trigger_cmd));
 717                         pthread_mutex_unlock(&m_trigger);
 718                         rc = do_work(kid);
 719                 } else {
 720                         pthread_mutex_unlock(&m_trigger);
 721                 }
 722         }
 723
 724         if (o_verbose > 1)
 725                 printf("%s: thread #%d done (%d)\n", cmdname, thread, rc);
 726
 727         if (rc)
 728                 stop_all(SIGINT);
 729
 730 out:
 731         err = cleanup(ename, 0);
 732         if (!rc) rc = err;
 733         err = cleanup(oname, 0);
 734         if (!rc) rc = err;
 735
 736         pthread_exit((void *)(long)rc);
 737 }
 738
 739 /*
 740  * PTHREAD_STACK_MIN is 16K minimal stack for threads. This
 741  * is stack consumed by one thread, which executes NULL procedure.
 742  * We need some more here and 20k stack for one client thread
 743  * is enough to not overflow. In same time it does not consume
 744  * a lot of memory for large number of threads.
 745  *
 746  * 20K virtual clients will only consume 320M + 400M. Still to
 747  * create this number of virtual clients we need to fix 8192
 748  * OBDs limit.
 749  */
 750 #define CLIENT_THREAD_STACK_SIZE (PTHREAD_STACK_MIN + (20 * 1024))
 751
 752 static int loadgen_start_clients(int argc, char **argv)
 753 {
 754         int rc = 0, i, numt;
 755         struct timespec ts = {0, 1000*1000*100}; /* .1 sec */
 756         pthread_attr_t attr;
 757
 758         if (argc != 2)
 759                 return CMD_HELP;
 760
 761         numt = strtoul(argv[1], NULL, 0);
 762         if (numt < 1)
 763                 return CMD_HELP;
 764
 765         if (!target[0]) {
 766                 fprintf(stderr, "%s: target OST is not defined, use 'device' "
 767                         "command\n", cmdname);
 768                 return -EINVAL;
 769         }
 770
 771         rc = pthread_attr_init(&attr);
 772         if (rc) {
 773                 fprintf(stderr, "%s: pthread_attr_init:(%d) %s\n",
 774                         cmdname, rc, strerror(errno));
 775                 return -errno;
 776         }
 777         pthread_attr_setstacksize (&attr, CLIENT_THREAD_STACK_SIZE);
 778         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 779
 780         numt += live_threads;
 781         i = live_threads;
 782         printf("start %d to %d\n", i, numt);
 783         while(!rc && !sig_received && (i < numt)) {
 784                 pthread_t thread;
 785
 786                 i++;
 787                 rc = pthread_create(&thread, &attr, run_one_child,
 788                                     (void *)(long)i);
 789                 if (rc) {
 790                         fprintf(stderr, "%s: pthread: #%d - (%d) %s\n",
 791                                 cmdname, i, rc, strerror(rc));
 792                         break;
 793                 }
 794
 795                 /* give them slightly different start times */
 796                 nanosleep(&ts, NULL);
 797         }
 798
 799         pthread_attr_destroy(&attr);
 800
 801         return -rc;
 802 }
 803
 804 static int loadgen_target(int argc, char **argv)
 805 {
 806         char *args[3];
 807         __u64 nidx = 0;
 808         int rc = 0;
 809
 810         if (argc < 2 || argc > 3)
 811                 return CMD_HELP;
 812
 813         args[0] = cmdname;
 814
 815         if (argc == 3) {
 816                 nidx = libcfs_str2nid(argv[2]);
 817                 if (nidx == LNET_NID_ANY) {
 818                         fprintf(stderr, "%s: invalid nid '%s'\n",
 819                                 cmdname, argv[2]);
 820                         return -EINVAL;
 821                 }
 822         } else {
 823                 /* Local device should be in list */
 824                 args[1] = argv[1];
 825                 rc = jt_obd_device(2, args);
 826                 if (rc) {
 827                         fprintf(stderr, "%s: local device '%s' doesn't "
 828                                 "seem to exist. You must use obdfilter device "
 829                                 "names like 'lustre-OST0000'.  Use 'dl' to "
 830                                 "list all devices.\n",
 831                                 cmdname, argv[1]);
 832                         return -EINVAL;
 833                 }
 834
 835                 /* Use the first local nid */
 836                 args[1] = (char *)(&nidx);
 837                 args[1][0] = 1; /* hack to get back first nid */
 838                 rc = jt_ptl_list_nids(2, args);
 839                 if (rc) {
 840                         fprintf(stderr, "%s: can't get local nid (%d)\n",
 841                                 cmdname, rc);
 842                         return rc;
 843                 }
 844         }
 845         if (strcmp(nid, libcfs_nid2str(nidx)) != 0) {
 846                 /* if new, do an add_uuid */
 847                 sprintf(nid, "%s", libcfs_nid2str(nidx));
 848
 849                 /* Fixme change the uuid for every new one */
 850                 args[1] = "OSS_UUID";
 851                 args[2] = nid;
 852                 rc = jt_lcfg_add_uuid(3, args);
 853                 if (rc) {
 854                         fprintf(stderr, "%s: can't add uuid '%s' (%d)\n",
 855                                 cmdname, args[2], rc);
 856                         return rc;
 857                 }
 858         }
 859
 860         snprintf(target, sizeof(target), "%s", argv[1]);
 861         printf("Target OST name is '%s'\n", target);
 862
 863         return rc;
 864 }
 865
 866 static int loadgen_verbose(int argc, char **argv)
 867 {
 868         if (argc != 2)
 869                 return CMD_HELP;
 870         o_verbose = atoi(argv[1]);
 871         printf("verbosity set to %d\n", o_verbose);
 872         return 0;
 873 }
 874
 875 static int loadgen_write(int argc, char **argv)
 876 {
 877         int threads;
 878
 879         if (argc < 3 || argc > 4)
 880                 return CMD_HELP;
 881         threads = atoi(argv[1]);
 882         pthread_mutex_lock(&m_list);
 883         if (threads > live_threads) {
 884                 pthread_mutex_unlock(&m_list);
 885                 fprintf(stderr, "requested %d threads but only %d are running. "
 886                         "Use 'start' to start some more.\n",
 887                         threads, live_threads);
 888                 return -EOVERFLOW;
 889         } else {
 890                 pthread_mutex_unlock(&m_list);
 891         }
 892         trigger(C_WRITE, threads, atoi(argv[2]),
 893                 (argc == 4) ? atoi(argv[3]) : 0);
 894         return 0;
 895 }
 896
 897 char ecsname[] = "echosrv";
 898 static int loadgen_stop_echosrv(int argc, char **argv)
 899 {
 900         int verbose = (argc != 9);
 901         if (my_oss) {
 902                 char name[]="OSS";
 903                 cleanup(name, verbose);
 904                 my_oss = 0;
 905         }
 906         if (my_ecs || (argc == 9)) {
 907                 cleanup(ecsname, verbose);
 908                 my_ecs = 0;
 909         }
 910         return 0;
 911 }
 912
 913 static int loadgen_start_echosrv(int argc, char **argv)
 914 {
 915         char *args[5];
 916         int rc;
 917
 918         pthread_mutex_lock(&m_config);
 919
 920         args[0] = cmdname;
 921
 922         /* attach obdecho echosrv echosrv_UUID */
 923         args[1] = "obdecho";
 924         args[2] = args[3] = ecsname;
 925         rc = jt_lcfg_attach(4, args);
 926         if (rc) {
 927                 fprintf(stderr, "%s: can't attach echo server (%d)\n",
 928                         cmdname, rc);
 929                 /* Assume we want e.g. an old one cleaned anyhow. */
 930                 goto clean;
 931         }
 932         my_ecs = 1;
 933
 934         /* setup */
 935         rc = jt_lcfg_setup(1, args);
 936         if (rc) {
 937                 fprintf(stderr, "%s: can't setup echo server (%d)\n",
 938                         cmdname, rc);
 939                 goto clean;
 940         }
 941
 942         /* Create an OSS to handle the communications */
 943         /* attach ost OSS OSS_UUID */
 944         args[1] = "ost";
 945         args[2] = args[3] = "OSS";
 946
 947         rc = jt_lcfg_attach(4, args);
 948         if (rc == EEXIST) {
 949                 /* Already set up for somebody else, that's fine. */
 950                 printf("OSS already set up, no problem.\n");
 951                 pthread_mutex_unlock(&m_config);
 952                 return 0;
 953         }
 954         if (rc) {
 955                 fprintf(stderr, "%s: can't attach OSS (%d)\n",
 956                         cmdname, rc);
 957                 goto clean;
 958         }
 959         my_oss = 1;
 960
 961         /* setup */
 962         rc = jt_lcfg_setup(1, args);
 963         if (rc) {
 964                 fprintf(stderr, "%s: can't setup OSS (%d)\n",
 965                         cmdname, rc);
 966                 goto clean;
 967         }
 968
 969         pthread_mutex_unlock(&m_config);
 970         return rc;
 971
 972 clean:
 973         pthread_mutex_unlock(&m_config);
 974         loadgen_stop_echosrv(9, argv);
 975         return rc;
 976 }
 977
 978 static int loadgen_wait(int argc, char **argv)
 979 {
 980         /* Give scripts a chance to start some threads */
 981         sleep(1);
 982         while (!all_done) {
 983                 sleep(1);
 984         }
 985         return 0;
 986 }
 987
 988 static int loadgen_init(int argc, char **argv)
 989 {
 990         char *args[4];
 991         int rc;
 992
 993         sprintf(cmdname, "%s", argv[0]);
 994
 995         signal(SIGTERM, sig_master);
 996         signal(SIGINT, sig_master);
 997
 998         /* Test to make sure obdecho module is loaded */
 999         args[0] = cmdname;
1000         args[1] = "echo_client";
1001         args[2] = args[3] = "ecc_test";
1002         rc = jt_lcfg_attach(4, args);
1003         if (rc) {
1004                 fprintf(stderr, "%s: can't attach echo client (%d)\n",
1005                         cmdname, rc);
1006                 if (rc == ENODEV)
1007                         fprintf(stderr, "%s: is the obdecho module loaded?\n",
1008                                 cmdname);
1009         } else {
1010                 args[1] = args[2];
1011                 jt_obd_detach(1, args);
1012         }
1013
1014         return rc;
1015 }
1016
1017 static int loadgen_exit()
1018 {
1019         int rc;
1020
1021         printf("stopping %d children\n", live_threads);
1022         kill_kids();
1023         rc = wait_for_threads();
1024
1025         loadgen_stop_echosrv(0, NULL);
1026
1027         return rc;
1028 }
1029
1030 /* libptlctl interface */
1031 static int loadgen_main(int argc, char **argv)
1032 {
1033         int rc;
1034
1035         setlinebuf(stdout);
1036         /* without this threaded errors cause segfault */
1037         setlinebuf(stderr);
1038
1039         if ((rc = ptl_initialize(argc, argv)) < 0)
1040                 exit(rc);
1041         if ((rc = obd_initialize(argc, argv)) < 0)
1042                 exit(rc);
1043         if ((rc = dbg_initialize(argc, argv)) < 0)
1044                 exit(rc);
1045
1046         Parser_init("loadgen> ", cmdlist);
1047
1048         rc = loadgen_init(argc, argv);
1049         if (rc)
1050                 goto out;
1051
1052         if (argc > 1) {
1053                 rc = Parser_execarg(argc - 1, argv + 1, cmdlist);
1054         } else {
1055                 rc = Parser_commands();
1056         }
1057
1058         rc = loadgen_exit();
1059
1060 out:
1061         obd_finalize(argc, argv);
1062         return rc < 0 ? -rc : rc;
1063 }
1064
1065 #ifndef LIBLUSTRE_TEST
1066 int main (int argc, char **argv)
1067 {
1068         int rc;
1069         rc = loadgen_main(argc, argv);
1070         pthread_exit((void *)(long)rc);
1071
1072         return rc;
1073 }
1074 #endif