loadgen.c

来自「lustre 1.6.5 source code」· C语言 代码 · 共 1,038 行 · 第 1/3 页

                                       trigger_cmd.c_flags);
                        trigger_count--;
                        memcpy(&kid->k_cmd, &trigger_cmd, sizeof(trigger_cmd));
                        pthread_mutex_unlock(&m_trigger);
                        rc = do_work(kid);
                } else {
                        pthread_mutex_unlock(&m_trigger);
                }
        }

        if (o_verbose > 1)
                printf("%s: thread #%d done (%d)\n", cmdname, thread, rc);

        if (rc)
                stop_all(SIGINT);

out:
        err = cleanup(ename, 0);
        if (!rc) rc = err;
        err = cleanup(oname, 0);
        if (!rc) rc = err;

        pthread_exit((void *)(long)rc);
}

static int loadgen_start_clients(int argc, char **argv)
{
        int rc = 0, i, numt;
        struct timespec ts = {0, 1000*1000*100}; /* .1 sec */
        pthread_attr_t attr;

        if (argc != 2)
                return CMD_HELP;

        numt = strtoul(argv[1], NULL, 0);
        if (numt < 1)
                return CMD_HELP;

        if (!target[0]) {
                fprintf(stderr, "%s: target OST is not defined, use 'device' "
                        "command\n", cmdname);
                return -EINVAL;
        }

        rc = pthread_attr_init(&attr);
        if (rc) {
                fprintf(stderr, "%s: pthread_attr_init:(%d) %s\n",
                        cmdname, rc, strerror(errno));
                return -errno;
        }
        pthread_attr_setstacksize (&attr, PTHREAD_STACK_MIN);
        pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);

        numt += live_threads;
        i = live_threads;
        printf("start %d to %d\n", i, numt);
        while(!rc && !sig_received && (i < numt)) {
                pthread_t thread;

                i++;
                rc = pthread_create(&thread, &attr, run_one_child,
                                    (void *)(long)i);
                if (rc) {
                        fprintf(stderr, "%s: pthread: #%d - (%d) %s\n",
                                cmdname, i, rc, strerror(rc));
                        break;
                }

                /* give them slightly different start times */
                nanosleep(&ts, NULL);
        }

        pthread_attr_destroy(&attr);

        return -rc;
}

static int loadgen_target(int argc, char **argv)
{
        char *args[3];
        __u64 nidx = 0;
        int rc = 0;

        if (argc < 2 || argc > 3)
                return CMD_HELP;

        args[0] = cmdname;

        if (argc == 3) {
                nidx = libcfs_str2nid(argv[2]);
                if (nidx == LNET_NID_ANY) {
                        fprintf(stderr, "%s: invalid nid '%s'\n",
                                cmdname, argv[2]);
                        return -EINVAL;
                }
        } else {
                /* Local device should be in list */
                args[1] = argv[1];
                rc = jt_obd_device(2, args);
                if (rc) {
                        fprintf(stderr, "%s: local device '%s' doesn't "
                                "seem to exist. You must use obdfilter device "
                                "names like 'lustre-OST0000'.  Use 'dl' to "
                                "list all devices.\n",
                                cmdname, argv[1]);
                        return -EINVAL;
                }

                /* Use the first local nid */
                args[1] = (char *)(&nidx);
                args[1][0] = 1; /* hack to get back first nid */
                rc = jt_ptl_list_nids(2, args);
                if (rc) {
                        fprintf(stderr, "%s: can't get local nid (%d)\n",
                                cmdname, rc);
                        return rc;
                }
        }
        if (strcmp(nid, libcfs_nid2str(nidx)) != 0) {
                /* if new, do an add_uuid */
                sprintf(nid, "%s", libcfs_nid2str(nidx));

                /* Fixme change the uuid for every new one */
                args[1] = "OSS_UUID";
                args[2] = nid;
                rc = jt_lcfg_add_uuid(3, args);
                if (rc) {
                        fprintf(stderr, "%s: can't add uuid '%s' (%d)\n",
                                cmdname, args[2], rc);
                        return rc;
                }
        }

        snprintf(target, sizeof(target), "%s", argv[1]);
        printf("Target OST name is '%s'\n", target);

        return rc;
}

static int loadgen_verbose(int argc, char **argv)
{
        if (argc != 2)
                return CMD_HELP;
        o_verbose = atoi(argv[1]);
        printf("verbosity set to %d\n", o_verbose);
        return 0;
}

static int loadgen_write(int argc, char **argv)
{
        int threads;

        if (argc < 3 || argc > 4)
                return CMD_HELP;
        threads = atoi(argv[1]);
        if (threads > live_threads) {
                fprintf(stderr, "requested %d threads but only %d are running. "
                        "Use 'start' to start some more.\n",
                        threads, live_threads);
                return -EOVERFLOW;
        }
        trigger(C_WRITE, threads, atoi(argv[2]), 
                (argc == 4) ? atoi(argv[3]) : 0);
        return 0;
}

char ecsname[] = "echosrv";
static int loadgen_stop_echosrv(int argc, char **argv)
{
        int verbose = (argc != 9);
        if (my_oss) {
                char name[]="OSS";
                cleanup(name, verbose);
                my_oss = 0;
        }
        if (my_ecs || (argc == 9)) {
                cleanup(ecsname, verbose);
                my_ecs = 0;
        }
        return 0;
}

static int loadgen_start_echosrv(int argc, char **argv)
{
        char *args[5];
        int rc;

        pthread_mutex_lock(&m_config);

        args[0] = cmdname;

        /* attach obdecho echosrv echosrv_UUID */
        args[1] = "obdecho";
        args[2] = args[3] = ecsname;
        rc = jt_lcfg_attach(4, args);
        if (rc) {
                fprintf(stderr, "%s: can't attach echo server (%d)\n",
                        cmdname, rc);
                /* Assume we want e.g. an old one cleaned anyhow. */
                goto clean;
        }
        my_ecs = 1;

        /* setup */
        rc = jt_lcfg_setup(1, args);
        if (rc) {
                fprintf(stderr, "%s: can't setup echo server (%d)\n",
                        cmdname, rc);
                goto clean;
        }
  
        /* Create an OSS to handle the communications */
        /* attach ost OSS OSS_UUID */
        args[1] = "ost";
        args[2] = args[3] = "OSS";

        rc = jt_lcfg_attach(4, args);
        if (rc == EEXIST) {
                /* Already set up for somebody else, that's fine. */
                printf("OSS already set up, no problem.\n");
                pthread_mutex_unlock(&m_config);
                return 0;
        }
        if (rc) {
                fprintf(stderr, "%s: can't attach OSS (%d)\n",
                        cmdname, rc);
                goto clean;
        }
        my_oss = 1;

        /* setup */
        rc = jt_lcfg_setup(1, args);
        if (rc) {
                fprintf(stderr, "%s: can't setup OSS (%d)\n",
                        cmdname, rc);
                goto clean;
        }

        pthread_mutex_unlock(&m_config);
        return rc;

clean:
        pthread_mutex_unlock(&m_config);
        loadgen_stop_echosrv(9, argv);
        return rc;
}

static int loadgen_wait(int argc, char **argv)
{
        /* Give scripts a chance to start some threads */   
        sleep(1);
        while (!all_done) {
                sleep(1);
        }
        return 0;
}

static int loadgen_init(int argc, char **argv)
{
        char *args[3];
        int rc;

        sprintf(cmdname, "%s", argv[0]);

        signal(SIGTERM, sig_master);
        signal(SIGINT, sig_master);

        /* Test to make sure obdecho module is loaded */
        args[0] = cmdname;
        args[1] = "echo_client";
        args[2] = args[3] = "ecc_test";
        rc = jt_lcfg_attach(4, args);
        if (rc) {
                fprintf(stderr, "%s: can't attach echo client (%d)\n",
                        cmdname, rc);
                if (rc == ENODEV)
                        fprintf(stderr, "%s: is the obdecho module loaded?\n",
                                cmdname);
        } else {
                args[1] = args[2];
                jt_obd_detach(1, args);
        }

        return rc;
}

static int loadgen_exit()
{
        int rc;
        
        printf("stopping %d children\n", live_threads);
        kill_kids();
        rc = wait_for_threads();

        loadgen_stop_echosrv(0, NULL);

        return rc;
}

/* libptlctl interface */
static int loadgen_main(int argc, char **argv)
{
        int rc;

        setlinebuf(stdout);
        /* without this threaded errors cause segfault */
        setlinebuf(stderr);

        if ((rc = ptl_initialize(argc, argv)) < 0)
                exit(rc);
        if ((rc = obd_initialize(argc, argv)) < 0)
                exit(rc);
        if ((rc = dbg_initialize(argc, argv)) < 0)
                exit(rc);

        Parser_init("loadgen> ", cmdlist);

        rc = loadgen_init(argc, argv);
        if (rc)
                goto out;

        if (argc > 1) {
                rc = Parser_execarg(argc - 1, argv + 1, cmdlist);
        } else {
                rc = Parser_commands();
        }

        rc = loadgen_exit();

out:
        obd_finalize(argc, argv);
        return rc;
}

#ifndef LIBLUSTRE_TEST
int main (int argc, char **argv)
{
        int rc;
        rc = loadgen_main(argc, argv);
        pthread_exit((void *)(long)rc);

        return rc;
}
#endif