lst.c

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

                        break;
                default:
                        lst_print_usage(argv[0]);
                        return -1;
                }
        }

        if (optind == argc) {
                /* no group is specified, list name of all groups */
                rc = lst_list_group_all();

                return rc;
        }

        if (!verbose)
                fprintf(stdout, LST_NODES_TITLE);

        /* list nodes in specified groups */
        for (i = optind; i < argc; i++) {
                rc = lst_info_group_ioctl(argv[i], &gent, NULL, NULL, NULL);
                if (rc != 0) {
                        if (errno == ENOENT) {
                                rc = 0;
                                break;
                        }

                        lst_print_error("group", "Failed to list group\n",
                                        strerror(errno));
                        break;
                }

                if (!verbose) {
                        fprintf(stdout, "\t%d\t%d\t%d\t%d\t%d\t%s\n",
                                gent.nle_nactive, gent.nle_nbusy,
                                gent.nle_ndown, gent.nle_nunknown,
                                gent.nle_nnode, argv[i]);
                        continue;
                }

                fprintf(stdout, "Group [ %s ]\n", argv[i]);

                if (gent.nle_nnode == 0) {
                        fprintf(stdout, "No nodes found [ %s ]\n", argv[i]);
                        continue;
                }

                count = gent.nle_nnode;

                dents = malloc(count * sizeof(lstcon_node_ent_t));
                if (dents == NULL) {
                        fprintf(stderr, "Failed to malloc: %s\n",
                                strerror(errno));
                        return -1;
                }

                index = 0;
                rc = lst_info_group_ioctl(argv[i], &gent, &index, &count, dents);
                if (rc != 0) {
                        lst_print_error("group", "Failed to list group: %s\n",
                                        strerror(errno));
                        free(dents);
                        return -1;
                }

                for (j = 0, c = 0; j < count; j++) {
                        if (all ||
                            ((active  &&  dents[j].nde_state == LST_NODE_ACTIVE) ||
                             (busy    &&  dents[j].nde_state == LST_NODE_BUSY)   ||
                             (down    &&  dents[j].nde_state == LST_NODE_DOWN)   ||
                             (unknown &&  dents[j].nde_state == LST_NODE_UNKNOWN))) {

                                fprintf(stdout, "\t%s: %s\n",
                                        libcfs_id2str(dents[j].nde_id),
                                        lst_node_state2str(dents[j].nde_state));
                                c++;
                        }
                }

                fprintf(stdout, "Total %d nodes [ %s ]\n", c, argv[i]);

                free(dents);
        }

        return rc;
}

int
lst_stat_ioctl (char *name, int count, lnet_process_id_t *idsp,
                int timeout, struct list_head *resultp)
{
        lstio_stat_args_t  args = {
                .lstio_sta_key           = session_key,
                .lstio_sta_timeout       = timeout,
                .lstio_sta_nmlen         = strlen(name),
                .lstio_sta_namep         = name,
                .lstio_sta_count         = count,
                .lstio_sta_idsp          = idsp,
                .lstio_sta_resultp       = resultp,
        };

        return lst_ioctl (LSTIO_STAT_QUERY, &args, sizeof(args));
}

typedef struct {
        struct list_head        srp_link;
        int                     srp_count;
        char                   *srp_name;
        lnet_process_id_t      *srp_ids;
        struct list_head        srp_result[2];
} lst_stat_req_param_t;

static void
lst_stat_req_param_free(lst_stat_req_param_t *srp)
{
        int     i;

        for (i = 0; i < 2; i++) 
                lst_free_rpcent(&srp->srp_result[i]);

        if (srp->srp_ids != NULL)
                free(srp->srp_ids);

        free(srp);
}

static int
lst_stat_req_param_alloc(char *name, lst_stat_req_param_t **srpp, int save_old)
{
        lst_stat_req_param_t *srp = NULL;
        int                   count = save_old ? 2 : 1;
        int                   rc;
        int                   i;

        srp = malloc(sizeof(*srp));
        if (srp == NULL)
                return -ENOMEM;

        memset(srp, 0, sizeof(*srp));
        CFS_INIT_LIST_HEAD(&srp->srp_result[0]);
        CFS_INIT_LIST_HEAD(&srp->srp_result[1]);

        rc = lst_get_node_count(LST_OPC_GROUP, name,
                                &srp->srp_count, NULL);
        if (rc != 0 && errno == ENOENT) {
                rc = lst_get_node_count(LST_OPC_NODES, name,
                                        &srp->srp_count, &srp->srp_ids);
        }

        if (rc != 0) {
                fprintf(stderr,
                        "Failed to get count of nodes from %s: %s\n",
                        name, strerror(errno));
                lst_stat_req_param_free(srp);

                return rc;
        }

        srp->srp_name = name;

        for (i = 0; i < count; i++) {
                rc = lst_alloc_rpcent(&srp->srp_result[i], srp->srp_count,
                                      sizeof(sfw_counters_t)  +
                                      sizeof(srpc_counters_t) +
                                      sizeof(lnet_counters_t));
                if (rc != 0) {
                        fprintf(stderr, "Out of memory\n");
                        break;
                }
        }

        if (rc == 0) {
                *srpp = srp;
                return 0;
        }

        lst_stat_req_param_free(srp);

        return rc;
}

typedef struct {
        /* TODO */
} lst_srpc_stat_result;

#define LST_LNET_AVG    0
#define LST_LNET_MIN    1
#define LST_LNET_MAX    2

typedef struct {
        float           lnet_avg_sndrate;
        float           lnet_min_sndrate;
        float           lnet_max_sndrate;
        float           lnet_total_sndrate;

        float           lnet_avg_rcvrate;
        float           lnet_min_rcvrate;
        float           lnet_max_rcvrate;
        float           lnet_total_rcvrate;

        float           lnet_avg_sndperf;
        float           lnet_min_sndperf;
        float           lnet_max_sndperf;
        float           lnet_total_sndperf;

        float           lnet_avg_rcvperf;
        float           lnet_min_rcvperf;
        float           lnet_max_rcvperf;
        float           lnet_total_rcvperf;

        int             lnet_stat_count;
} lst_lnet_stat_result_t;

lst_lnet_stat_result_t lnet_stat_result;

static float
lst_lnet_stat_value(int bw, int send, int off)
{
        float  *p;

        p = bw ? &lnet_stat_result.lnet_avg_sndperf :
                 &lnet_stat_result.lnet_avg_sndrate;

        if (!send)
                p += 4; 

        p += off;

        return *p;
}

static void
lst_timeval_diff(struct timeval *tv1,
                 struct timeval *tv2, struct timeval *df)
{
        if (tv1->tv_usec >= tv2->tv_usec) {
                df->tv_sec  = tv1->tv_sec - tv2->tv_sec;
                df->tv_usec = tv1->tv_usec - tv2->tv_usec;
                return;
        }

        df->tv_sec  = tv1->tv_sec - 1 - tv2->tv_sec;
        df->tv_usec = tv1->tv_sec + 1000000 - tv2->tv_usec;

        return;
}

void
lst_cal_lnet_stat(float delta, lnet_counters_t *lnet_new,
                  lnet_counters_t *lnet_old)
{
        float perf;
        float rate;

        perf = (float)(lnet_new->send_length -
                       lnet_old->send_length) / (1024 * 1024) / delta;
        lnet_stat_result.lnet_total_sndperf += perf;

        if (lnet_stat_result.lnet_min_sndperf > perf ||
            lnet_stat_result.lnet_min_sndperf == 0)
                lnet_stat_result.lnet_min_sndperf = perf;

        if (lnet_stat_result.lnet_max_sndperf < perf)
                lnet_stat_result.lnet_max_sndperf = perf;

        perf = (float)(lnet_new->recv_length -
                       lnet_old->recv_length) / (1024 * 1024) / delta;
        lnet_stat_result.lnet_total_rcvperf += perf;

        if (lnet_stat_result.lnet_min_rcvperf > perf ||
            lnet_stat_result.lnet_min_rcvperf == 0)
                lnet_stat_result.lnet_min_rcvperf = perf;

        if (lnet_stat_result.lnet_max_rcvperf < perf)
                lnet_stat_result.lnet_max_rcvperf = perf;

        rate = (lnet_new->send_count - lnet_old->send_count) / delta;
        lnet_stat_result.lnet_total_sndrate += rate;

        if (lnet_stat_result.lnet_min_sndrate > rate ||
            lnet_stat_result.lnet_min_sndrate == 0)
                lnet_stat_result.lnet_min_sndrate = rate;

        if (lnet_stat_result.lnet_max_sndrate < rate)
                lnet_stat_result.lnet_max_sndrate = rate;

        rate = (lnet_new->recv_count - lnet_old->recv_count) / delta;
        lnet_stat_result.lnet_total_rcvrate += rate;

        if (lnet_stat_result.lnet_min_rcvrate > rate ||
            lnet_stat_result.lnet_min_rcvrate == 0)
                lnet_stat_result.lnet_min_rcvrate = rate;

        if (lnet_stat_result.lnet_max_rcvrate < rate)
                lnet_stat_result.lnet_max_rcvrate = rate;

        lnet_stat_result.lnet_stat_count ++;

        lnet_stat_result.lnet_avg_sndrate = lnet_stat_result.lnet_total_sndrate /
                                            lnet_stat_result.lnet_stat_count;
        lnet_stat_result.lnet_avg_rcvrate = lnet_stat_result.lnet_total_rcvrate /
                                            lnet_stat_result.lnet_stat_count;

        lnet_stat_result.lnet_avg_sndperf = lnet_stat_result.lnet_total_sndperf /
                                            lnet_stat_result.lnet_stat_count;
        lnet_stat_result.lnet_avg_rcvperf = lnet_stat_result.lnet_total_rcvperf /
                                            lnet_stat_result.lnet_stat_count;

}

void
lst_print_lnet_stat(char *name, int bwrt, int rdwr, int type)
{
        int     start1 = 0;
        int     end1   = 1;
        int     start2 = 0;
        int     end2   = 1;
        int     i;
        int     j;

        if (lnet_stat_result.lnet_stat_count == 0)
                return;

        if (bwrt == 1) /* bw only */
                start1 = 1;

        if (bwrt == 2) /* rates only */
                end1 = 0;

        if (rdwr == 1) /* recv only */
                start2 = 1;

        if (rdwr == 2) /* send only */
                end2 = 0;

        for (i = start1; i <= end1; i++) {
                fprintf(stdout, "[LNet %s of %s]\n",
                        i == 0 ? "Rates" : "Bandwidth", name);

                for (j = start2; j <= end2; j++) {
                        fprintf(stdout, "[%c] ", j == 0 ? 'R' : 'W');

                        if ((type & 1) != 0) {
                                fprintf(stdout, i == 0 ? "Avg: %-8.0f RPC/s " :
                                                         "Avg: %-8.2f MB/s  ",
                                        lst_lnet_stat_value(i, j, 0));
                        }

                        if ((type & 2) != 0) {
                                fprintf(stdout, i == 0 ? "Min: %-8.0f RPC/s " :
                                                         "Min: %-8.2f MB/s  ",
                                        lst_lnet_stat_value(i, j, 1));
                        }

                        if ((type & 4) != 0) {
                                fprintf(stdout, i == 0 ? "Max: %-8.0f RPC/s" :
                                                         "Max: %-8.2f MB/s",
                                        lst_lnet_stat_value(i, j, 2));
                        }

                        fprintf(stdout, "\n");
                }
        }
}

void
lst_print_stat(char *name, struct list_head *resultp,
               int idx, int lnet, int bwrt, int rdwr, int type)
{
        struct list_head  tmp[2];
        lstcon_rpc_ent_t *new;
        lstcon_rpc_ent_t *old;
        sfw_counters_t   *sfwk_new;
        sfw_counters_t   *sfwk_old;
        srpc_counters_t  *srpc_new;
        srpc_counters_t  *srpc_old;
        lnet_counters_t  *lnet_new;
        lnet_counters_t  *lnet_old;
        struct timeval    tv;
        float             delta;
        int               errcount = 0;

        CFS_INIT_LIST_HEAD(&tmp[0]);
        CFS_INIT_LIST_HEAD(&tmp[1]);

        memset(&lnet_stat_result, 0, sizeof(lnet_stat_result));

        while (!list_empty(&resultp[idx])) {
                if (list_empty(&resultp[1 - idx])) {
                        fprintf(stderr, "Group is changed, re-run stat\n");
                        break;
                }

                new = list_entry(resultp[idx].next, lstcon_rpc_ent_t, rpe_link);
                old = list_entry(resultp[1 - idx].next, lstcon_rpc_ent_t, rpe_link);

                /* first time get stats result, can't calculate diff */
                if (new->rpe_peer.nid == LNET_NID_ANY)
                        break;

                if (new->rpe_peer.nid != old->rpe_peer.nid ||
                    new->rpe_peer.pid != old->rpe_peer.pid) {
                        /* Something wrong. i.e, somebody change the group */
                        break;
                }

                list_del(&new->rpe_link);
                list_add_tail(&new->rpe_link, &tmp[idx]);

                list_del(&old->rpe_link);
                list_add_tail(&old->rpe_link, &tmp[1 - idx]);

                if (new->rpe_rpc_errno != 0 || new->rpe_fwk_errno != 0 ||
                    old->rpe_rpc_errno != 0 || old->rpe_fwk_errno != 0) {
                        errcount ++;
                        continue;
                }

                sfwk_new = (sfw_counters_t *)&new->rpe_payload[0];
                sfwk_old = (sfw_counters_t *)&old->rpe_payload[0];

                srpc_new = (srpc_counters_t *)((char *)sfwk_new + sizeof(*sfwk_new));
                srpc_old = (srpc_counters_t *)((char *)sfwk_old + sizeof(*sfwk_old));

                lnet_new = (lnet_counters_t *)((char *)srpc_new + sizeof(*srpc_new));
                lnet_old = (lnet_counters_t *)((char *)srpc_old + sizeof(*srpc_old));

                lst_timeval_diff(&new->rpe_stamp, &old->rpe_stamp, &tv);

                delta = tv.tv_sec + (float)tv.tv_usec/1000000;

                if (!lnet) /* TODO */
                        continue;