console.c

lustre 1.6.5 source code

                                     &bat->bat_trans_list, transop,
                                     bat, lstcon_batrpc_condition, &trans);
        if (rc != 0) {
                CERROR("Can't create transaction: %d\n", rc);
                return rc;
        }

        lstcon_rpc_trans_postwait(trans, LST_TRANS_TIMEOUT);

        rc = lstcon_rpc_trans_interpreter(trans, result_up, NULL);

        lstcon_rpc_trans_destroy(trans);

        return rc;
}

int
lstcon_batch_run(char *name, int timeout, struct list_head *result_up)
{
        lstcon_batch_t *bat;
        int             rc;

        if (lstcon_batch_find(name, &bat) != 0) {
                CDEBUG(D_NET, "Can't find batch %s\n", name);
                return -ENOENT;
        }

        bat->bat_arg = timeout;

        rc = lstcon_batch_op(bat, LST_TRANS_TSBRUN, result_up);

        /* mark batch as running if it's started in any node */
        if (lstcon_tsbop_stat_success(lstcon_trans_stat(), 0) != 0)
                bat->bat_state = LST_BATCH_RUNNING;

        return rc;
}

int
lstcon_batch_stop(char *name, int force, struct list_head *result_up)
{
        lstcon_batch_t *bat;
        int             rc;

        if (lstcon_batch_find(name, &bat) != 0) {
                CDEBUG(D_NET, "Can't find batch %s\n", name);
                return -ENOENT;
        }

        bat->bat_arg = force;

        rc = lstcon_batch_op(bat, LST_TRANS_TSBSTOP, result_up);
        
        /* mark batch as stopped if all RPCs finished */
        if (lstcon_tsbop_stat_failure(lstcon_trans_stat(), 0) == 0)
                bat->bat_state = LST_BATCH_IDLE;

        return rc;
}

static void
lstcon_batch_destroy(lstcon_batch_t *bat)
{
        lstcon_ndlink_t    *ndl;
        lstcon_test_t      *test;
        int                 i;

        list_del(&bat->bat_link);

        while (!list_empty(&bat->bat_test_list)) {
                test = list_entry(bat->bat_test_list.next,
                                  lstcon_test_t, tes_link);
                LASSERT (list_empty(&test->tes_trans_list));

                list_del(&test->tes_link);

                lstcon_group_put(test->tes_src_grp);
                lstcon_group_put(test->tes_dst_grp);

                LIBCFS_FREE(test, offsetof(lstcon_test_t,
                                           tes_param[test->tes_paramlen]));
        }

        LASSERT (list_empty(&bat->bat_trans_list));

        while (!list_empty(&bat->bat_cli_list)) {
                ndl = list_entry(bat->bat_cli_list.next,
                                 lstcon_ndlink_t, ndl_link);
                list_del_init(&ndl->ndl_link);

                lstcon_ndlink_release(ndl);
        }

        while (!list_empty(&bat->bat_srv_list)) {
                ndl = list_entry(bat->bat_srv_list.next,
                                 lstcon_ndlink_t, ndl_link);
                list_del_init(&ndl->ndl_link);

                lstcon_ndlink_release(ndl);
        }

        for (i = 0; i < LST_NODE_HASHSIZE; i++) {
                LASSERT (list_empty(&bat->bat_cli_hash[i]));
                LASSERT (list_empty(&bat->bat_srv_hash[i]));
        }

        LIBCFS_FREE(bat->bat_cli_hash,
                    sizeof(struct list_head) * LST_NODE_HASHSIZE);
        LIBCFS_FREE(bat->bat_srv_hash,
                    sizeof(struct list_head) * LST_NODE_HASHSIZE);
        LIBCFS_FREE(bat, sizeof(lstcon_batch_t));
}

int
lstcon_testrpc_condition(int transop, lstcon_node_t *nd, void *arg)
{
        lstcon_test_t    *test;
        lstcon_batch_t   *batch;
        lstcon_ndlink_t  *ndl;
        struct list_head *hash;
        struct list_head *head;

        test = (lstcon_test_t *)arg;
        LASSERT (test != NULL);

        batch = test->tes_batch;
        LASSERT (batch != NULL);

        if (test->tes_oneside &&
            transop == LST_TRANS_TSBSRVADD)
                return 0;

        if (nd->nd_state != LST_NODE_ACTIVE)
                return -ENETDOWN;

        if (transop == LST_TRANS_TSBCLIADD) {
                hash = batch->bat_cli_hash;
                head = &batch->bat_cli_list;
        
        } else {
                LASSERT (transop == LST_TRANS_TSBSRVADD);

                hash = batch->bat_srv_hash;
                head = &batch->bat_srv_list;
        }

        LASSERT (nd->nd_id.nid != LNET_NID_ANY);

        if (lstcon_ndlink_find(hash, nd->nd_id, &ndl, 1) != 0)
                return -ENOMEM;

        if (list_empty(&ndl->ndl_link))
                list_add_tail(&ndl->ndl_link, head);

        return 1;
}

static int
lstcon_test_nodes_add(lstcon_test_t *test, struct list_head *result_up)
{
        lstcon_rpc_trans_t     *trans;
        lstcon_group_t         *grp;
        int                     transop;
        int                     rc;

        LASSERT (test->tes_src_grp != NULL);
        LASSERT (test->tes_dst_grp != NULL);

        transop = LST_TRANS_TSBSRVADD;
        grp  = test->tes_dst_grp;
again:
        rc = lstcon_rpc_trans_ndlist(&grp->grp_ndl_list,
                                     &test->tes_trans_list, transop,
                                     test, lstcon_testrpc_condition, &trans);
        if (rc != 0) {
                CERROR("Can't create transaction: %d\n", rc);
                return rc;
        }

        lstcon_rpc_trans_postwait(trans, LST_TRANS_TIMEOUT);

        if (lstcon_trans_stat()->trs_rpc_errno != 0 ||
            lstcon_trans_stat()->trs_fwk_errno != 0) {
                lstcon_rpc_trans_interpreter(trans, result_up, NULL);

                lstcon_rpc_trans_destroy(trans);
                /* return if any error */
                CDEBUG(D_NET, "Failed to add test %s, "
                              "RPC error %d, framework error %d\n",
                       transop == LST_TRANS_TSBCLIADD ? "client" : "server",
                       lstcon_trans_stat()->trs_rpc_errno,
                       lstcon_trans_stat()->trs_fwk_errno);

                return rc;
        }

        lstcon_rpc_trans_destroy(trans);

        if (transop == LST_TRANS_TSBCLIADD)
                return rc;

        transop = LST_TRANS_TSBCLIADD;
        grp = test->tes_src_grp;
        test->tes_cliidx = 0;

        /* requests to test clients */
        goto again;
}

int
lstcon_test_add(char *name, int type, int loop, int concur,
                int dist, int span, char *src_name, char * dst_name,
                void *param, int paramlen, int *retp, struct list_head *result_up)
                
{
        lstcon_group_t  *src_grp = NULL;
        lstcon_group_t  *dst_grp = NULL;
        lstcon_test_t   *test    = NULL;
        lstcon_batch_t  *batch;
        int              rc;

        rc = lstcon_batch_find(name, &batch);
        if (rc != 0) {
                CDEBUG(D_NET, "Can't find batch %s\n", name);
                return rc;
        }

        if (batch->bat_state != LST_BATCH_IDLE) {
                CDEBUG(D_NET, "Can't change running batch %s\n", name);
                return rc;
        }
        
        rc = lstcon_group_find(src_name, &src_grp);
        if (rc != 0) {
                CDEBUG(D_NET, "Can't find group %s\n", src_name);
                goto out;
        }

        rc = lstcon_group_find(dst_name, &dst_grp);
        if (rc != 0) {
                CDEBUG(D_NET, "Can't find group %s\n", dst_name);
                goto out;
        }

        if (dst_grp->grp_userland)
                *retp = 1;

        LIBCFS_ALLOC(test, offsetof(lstcon_test_t, tes_param[paramlen]));
        if (!test) {
                CERROR("Can't allocate test descriptor\n");
                rc = -ENOMEM;

                goto out;
        }

        memset(test, 0, offsetof(lstcon_test_t, tes_param[paramlen]));
        test->tes_hdr.tsb_id    = batch->bat_hdr.tsb_id;
        test->tes_batch         = batch;
        test->tes_type          = type;
        test->tes_oneside       = 0; /* TODO */
        test->tes_loop          = loop;
        test->tes_concur        = concur;
        test->tes_stop_onerr    = 1; /* TODO */
        test->tes_span          = span;
        test->tes_dist          = dist;
        test->tes_cliidx        = 0; /* just used for creating RPC */
        test->tes_src_grp       = src_grp;
        test->tes_dst_grp       = dst_grp;
        CFS_INIT_LIST_HEAD(&test->tes_trans_list);

        if (param != NULL) {
                test->tes_paramlen = paramlen;
                memcpy(&test->tes_param[0], param, paramlen);
        }

        rc = lstcon_test_nodes_add(test, result_up);

        if (rc != 0)
                goto out;

        if (lstcon_trans_stat()->trs_rpc_errno != 0 ||
            lstcon_trans_stat()->trs_fwk_errno != 0)
                CDEBUG(D_NET, "Failed to add test %d to batch %s\n", type, name);

        /* add to test list anyway, so user can check what's going on */
        list_add_tail(&test->tes_link, &batch->bat_test_list);

        batch->bat_ntest ++;
        test->tes_hdr.tsb_index = batch->bat_ntest;

        /*  hold groups so nobody can change them */
        return rc;
out:
        if (test != NULL)
                LIBCFS_FREE(test, offsetof(lstcon_test_t, tes_param[paramlen]));

        if (dst_grp != NULL)
                lstcon_group_put(dst_grp);

        if (src_grp != NULL)
                lstcon_group_put(src_grp);

        return rc;
}

int
lstcon_test_find(lstcon_batch_t *batch, int idx, lstcon_test_t **testpp)
{
        lstcon_test_t *test;

        list_for_each_entry(test, &batch->bat_test_list, tes_link) {
                if (idx == test->tes_hdr.tsb_index) {
                        *testpp = test;
                        return 0;
                }
        }

        return -ENOENT;
}

int
lstcon_tsbrpc_readent(int transop, srpc_msg_t *msg,
                      lstcon_rpc_ent_t *ent_up)
{
        srpc_batch_reply_t *rep = &msg->msg_body.bat_reply;

        LASSERT (transop == LST_TRANS_TSBCLIQRY ||
                 transop == LST_TRANS_TSBSRVQRY);

        /* positive errno, framework error code */
        if (copy_to_user(&ent_up->rpe_priv[0],
                         &rep->bar_active, sizeof(rep->bar_active)))
                return -EFAULT;

        return 0;
}

int
lstcon_test_batch_query(char *name, int testidx, int client,
                        int timeout, struct list_head *result_up)
{
        lstcon_rpc_trans_t *trans;
        struct list_head   *translist;
        struct list_head   *ndlist;
        lstcon_tsb_hdr_t   *hdr;
        lstcon_batch_t     *batch;
        lstcon_test_t      *test = NULL;
        int                 transop;
        int                 rc;

        rc = lstcon_batch_find(name, &batch);
        if (rc != 0) {
                CDEBUG(D_NET, "Can't find batch: %s\n", name);
                return rc;
        }

        if (testidx == 0) {
                translist = &batch->bat_trans_list;
                ndlist    = &batch->bat_cli_list;
                hdr       = &batch->bat_hdr;

        } else {
                /* query specified test only */
                rc = lstcon_test_find(batch, testidx, &test);
                if (rc != 0) {
                        CDEBUG(D_NET, "Can't find test: %d\n", testidx);
                        return rc;
                }
        
                translist = &test->tes_trans_list;
                ndlist    = &test->tes_src_grp->grp_ndl_list;
                hdr       = &test->tes_hdr;
        } 

        transop = client ? LST_TRANS_TSBCLIQRY : LST_TRANS_TSBSRVQRY;

        rc = lstcon_rpc_trans_ndlist(ndlist, translist, transop, hdr,
                                     lstcon_batrpc_condition, &trans);
        if (rc != 0) {
                CERROR("Can't create transaction: %d\n", rc);
                return rc;
        }

        lstcon_rpc_trans_postwait(trans, timeout);

        if (testidx == 0 && /* query a batch, not a test */
            lstcon_rpc_stat_failure(lstcon_trans_stat(), 0) == 0 &&
            lstcon_tsbqry_stat_run(lstcon_trans_stat(), 0) == 0) {
                /* all RPCs finished, and no active test */
                batch->bat_state = LST_BATCH_IDLE;
        }

        rc = lstcon_rpc_trans_interpreter(trans, result_up,
                                          lstcon_tsbrpc_readent);
        lstcon_rpc_trans_destroy(trans);

        return rc;
}

int
lstcon_statrpc_readent(int transop, srpc_msg_t *msg,
                       lstcon_rpc_ent_t *ent_up)
{
        srpc_stat_reply_t *rep = &msg->msg_body.stat_reply;
        sfw_counters_t    *sfwk_stat;
        srpc_counters_t   *srpc_stat;
        lnet_counters_t   *lnet_stat;
        
        if (rep->str_status != 0)
                return 0;

        sfwk_stat = (sfw_counters_t *)&ent_up->rpe_payload[0];
        srpc_stat = (srpc_counters_t *)((char *)sfwk_stat + sizeof(*sfwk_stat));
        lnet_stat = (lnet_counters_t *)((char *)srpc_stat + sizeof(*srpc_stat));

        if (copy_to_user(sfwk_stat, &rep->str_fw, sizeof(*sfwk_stat)) ||
            copy_to_user(srpc_stat, &rep->str_rpc, sizeof(*srpc_stat)) ||
            copy_to_user(lnet_stat, &rep->str_lnet, sizeof(*lnet_stat)))
                return -EFAULT;

        return 0;
}

int
lstcon_ndlist_stat(struct list_head *ndlist,
                   int timeout, struct list_head *result_up)
{
        struct list_head    head;
        lstcon_rpc_trans_t *trans;
        int                 rc;

        CFS_INIT_LIST_HEAD(&head);

        rc = lstcon_rpc_trans_ndlist(ndlist, &head,
                                     LST_TRANS_STATQRY, NULL, NULL, &trans);
        if (rc != 0) {
                CERROR("Can't create transaction: %d\n", rc);
                return rc;
        }

        timeout = (timeout > LST_TRANS_MIN_TIMEOUT) ? timeout :
                                                      LST_TRANS_MIN_TIMEOUT;
        lstcon_rpc_trans_postwait(trans, timeout);

        rc = lstcon_rpc_trans_interpreter(trans, result_up,
                                          lstcon_statrpc_readent);
        lstcon_rpc_trans_destroy(trans);

        return rc;
}

int
lstcon_group_stat(char *grp_name, int timeout, struct list_head *result_up)
{
        lstcon_group_t     *grp;
        int                 rc;

        rc = lstcon_group_find(grp_name, &grp);
        if (rc != 0) {
                CDEBUG(D_NET, "Can't find group %s\n", grp_name);
                return rc;
        }

        rc = lstcon_ndlist_stat(&grp->grp_ndl_list, timeout, result_up);

        lstcon_group_put(grp);

        return rc;
}

int
lstcon_nodes_stat(int count, lnet_process_id_t *ids_up,
                  int timeout, struct list_head *result_up)
{
        lstcon_ndlink_t         *ndl;
        lstcon_group_t          *tmp;
        lnet_process_id_t        id;
        int                      i;
        int                      rc;

        rc = lstcon_group_alloc(NULL, &tmp);
        if (rc != 0) {
                CERROR("Out of memory\n");
                return -ENOMEM;
        }

        for (i = 0 ; i < count; i++) {
                if (copy_from_user(&id, &ids_up[i], sizeof(id))) {
                        rc = -EFAULT;
                        break;
                }

                /* add to tmp group */
                rc = lstcon_group_ndlink_find(tmp, id, &ndl, 2);
                if (rc != 0) {
                        CDEBUG((rc == -ENOMEM) ? D_ERROR : D_NET,
                               "Failed to find or create %s: %d\n",