console.c

lustre 1.6.5 source code

                               libcfs_id2str(id), rc);
                        break;
                }
        }

        if (rc != 0) {
                lstcon_group_put(tmp);
                return rc;
        }

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

        lstcon_group_put(tmp);

        return rc;
}

int
lstcon_debug_ndlist(struct list_head *ndlist,
                    struct list_head *translist,
                    int timeout, struct list_head *result_up)
{
        lstcon_rpc_trans_t *trans;
        int                 rc;

        rc = lstcon_rpc_trans_ndlist(ndlist, translist, LST_TRANS_SESQRY,
                                     NULL, lstcon_sesrpc_condition, &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_sesrpc_readent);
        lstcon_rpc_trans_destroy(trans);

        return rc;
}

int
lstcon_session_debug(int timeout, struct list_head *result_up)
{
        return lstcon_debug_ndlist(&console_session.ses_ndl_list,
                                   NULL, timeout, result_up);
}

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

        rc = lstcon_batch_find(name, &bat);
        if (rc != 0)
                return -ENOENT;

        rc = lstcon_debug_ndlist(client ? &bat->bat_cli_list :
                                          &bat->bat_srv_list,
                                 NULL, timeout, result_up);

        return rc;
}

int
lstcon_group_debug(int timeout, char *name,
                   struct list_head *result_up)
{
        lstcon_group_t *grp;
        int             rc;

        rc = lstcon_group_find(name, &grp);
        if (rc != 0)
                return -ENOENT;

        rc = lstcon_debug_ndlist(&grp->grp_ndl_list, NULL,
                                 timeout, result_up);
        lstcon_group_put(grp);

        return rc;
}

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

        rc = lstcon_group_alloc(NULL, &grp);
        if (rc != 0) {
                CDEBUG(D_NET, "Out of memory\n");
                return rc;
        }

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

                /* node is added to tmp group */
                rc = lstcon_group_ndlink_find(grp, id, &ndl, 1);
                if (rc != 0) {
                        CERROR("Can't create node link\n");
                        break;
                }
        }

        if (rc != 0) {
                lstcon_group_put(grp);
                return rc;
        }

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

        lstcon_group_put(grp);

        return rc;
}

int
lstcon_session_match(lst_sid_t sid)
{
        return (console_session.ses_id.ses_nid   == sid.ses_nid &&
                console_session.ses_id.ses_stamp == sid.ses_stamp) ?  1: 0;
}

static void
lstcon_new_session_id(lst_sid_t *sid)
{
        lnet_process_id_t      id;

        LASSERT (console_session.ses_state == LST_SESSION_NONE);

        LNetGetId(1, &id);
        sid->ses_nid   = id.nid;
        sid->ses_stamp = cfs_time_current();
}

extern srpc_service_t lstcon_acceptor_service;

int
lstcon_session_new(char *name, int key,
                   int timeout,int force, lst_sid_t *sid_up)
{
        int     rc = 0;
        int     i;

        if (console_session.ses_state != LST_SESSION_NONE) {
                /* session exists */
                if (!force) {
                        CERROR("Session %s already exists\n",
                               console_session.ses_name);
                        return -EEXIST;
                }

                rc = lstcon_session_end();

                /* lstcon_session_end() only return local error */
                if  (rc != 0)
                        return rc;
        }

        for (i = 0; i < LST_GLOBAL_HASHSIZE; i++) {
                LASSERT (list_empty(&console_session.ses_ndl_hash[i]));
        }

        rc = lstcon_batch_add(LST_DEFAULT_BATCH);
        if (rc != 0)
                return rc;

        rc = lstcon_rpc_pinger_start();
        if (rc != 0) {
                lstcon_batch_t *bat;

                lstcon_batch_find(LST_DEFAULT_BATCH, &bat);
                lstcon_batch_destroy(bat);

                return rc;
        }

        lstcon_new_session_id(&console_session.ses_id);

        console_session.ses_key     = key;
        console_session.ses_state   = LST_SESSION_ACTIVE;
        console_session.ses_force   = !!force;
        console_session.ses_timeout = (timeout <= 0)? LST_CONSOLE_TIMEOUT:
                                                      timeout;
        strcpy(console_session.ses_name, name);

        if (copy_to_user(sid_up, &console_session.ses_id,
                         sizeof(lst_sid_t)) == 0)
                return rc;

        lstcon_session_end();

        return -EFAULT;
}

int
lstcon_session_info(lst_sid_t *sid_up, int *key_up,
                    lstcon_ndlist_ent_t *ndinfo_up, char *name_up, int len)
{
        lstcon_ndlist_ent_t *entp;
        lstcon_ndlink_t     *ndl;
        int                  rc = 0;
        
        if (console_session.ses_state != LST_SESSION_ACTIVE)
                return -ESRCH;

        LIBCFS_ALLOC(entp, sizeof(*entp));
        if (entp == NULL)
                return -ENOMEM;

        memset(entp, 0, sizeof(*entp));

        list_for_each_entry(ndl, &console_session.ses_ndl_list, ndl_link)
                LST_NODE_STATE_COUNTER(ndl->ndl_node, entp);

        if (copy_to_user(sid_up, &console_session.ses_id, sizeof(lst_sid_t)) ||
            copy_to_user(key_up, &console_session.ses_key, sizeof(int)) ||
            copy_to_user(ndinfo_up, entp, sizeof(*entp)) ||
            copy_to_user(name_up, console_session.ses_name, len))
                rc = -EFAULT;

        LIBCFS_FREE(entp, sizeof(*entp));

        return rc;
}

int
lstcon_session_end()
{
        lstcon_rpc_trans_t *trans;
        lstcon_group_t     *grp;
        lstcon_batch_t     *bat;
        int                 rc = 0;

        LASSERT (console_session.ses_state == LST_SESSION_ACTIVE);

        rc = lstcon_rpc_trans_ndlist(&console_session.ses_ndl_list, 
                                     NULL, LST_TRANS_SESEND, NULL,
                                     lstcon_sesrpc_condition, &trans);
        if (rc != 0) {
                CERROR("Can't create transaction: %d\n", rc);
                return rc;
        }

        console_session.ses_shutdown = 1;

        lstcon_rpc_pinger_stop();

        lstcon_rpc_trans_postwait(trans, LST_TRANS_TIMEOUT);

        lstcon_rpc_trans_destroy(trans);
        /* User can do nothing even rpc failed, so go on */

        /* waiting for orphan rpcs to die */
        lstcon_rpc_cleanup_wait();

        console_session.ses_id    = LST_INVALID_SID;
        console_session.ses_state = LST_SESSION_NONE;
        console_session.ses_key   = 0;
        console_session.ses_force = 0;

        /* destroy all batches */
        while (!list_empty(&console_session.ses_bat_list)) {
                bat = list_entry(console_session.ses_bat_list.next,
                                 lstcon_batch_t, bat_link);

                lstcon_batch_destroy(bat);
        }

        /* destroy all groups */
        while (!list_empty(&console_session.ses_grp_list)) {
                grp = list_entry(console_session.ses_grp_list.next,
                                 lstcon_group_t, grp_link);
                LASSERT (grp->grp_ref == 1);

                lstcon_group_put(grp);
        }

        /* all nodes should be released */
        LASSERT (list_empty(&console_session.ses_ndl_list));

        console_session.ses_shutdown = 0;
        console_session.ses_expired  = 0;

        return rc;
}

static int
lstcon_acceptor_handle (srpc_server_rpc_t *rpc)
{
        srpc_msg_t        *rep  = &rpc->srpc_replymsg;
        srpc_msg_t        *req  = &rpc->srpc_reqstbuf->buf_msg;
        srpc_join_reqst_t *jreq = &req->msg_body.join_reqst;
        srpc_join_reply_t *jrep = &rep->msg_body.join_reply;
        lstcon_group_t    *grp  = NULL;
        lstcon_ndlink_t   *ndl;
        int                rc   = 0;

        sfw_unpack_message(req);

        mutex_down(&console_session.ses_mutex);

        jrep->join_sid = console_session.ses_id;

        if (console_session.ses_id.ses_nid == LNET_NID_ANY) {
                jrep->join_status = ESRCH;
                goto out;
        }

        if (jreq->join_sid.ses_nid != LNET_NID_ANY &&
             !lstcon_session_match(jreq->join_sid)) {
                jrep->join_status = EBUSY;
                goto out;
        }

        if (lstcon_group_find(jreq->join_group, &grp) != 0) {
                rc = lstcon_group_alloc(jreq->join_group, &grp);
                if (rc != 0) {
                        CERROR("Out of memory\n");
                        goto out;
                }

                list_add_tail(&grp->grp_link,
                              &console_session.ses_grp_list);
                lstcon_group_addref(grp);
        }

        if (grp->grp_ref > 2) {
                /* Group in using */
                jrep->join_status = EBUSY;
                goto out;
        }

        rc = lstcon_group_ndlink_find(grp, rpc->srpc_peer, &ndl, 0);
        if (rc == 0) {
                jrep->join_status = EEXIST;
                goto out;
        }

        rc = lstcon_group_ndlink_find(grp, rpc->srpc_peer, &ndl, 1);
        if (rc != 0) {
                CERROR("Out of memory\n");
                goto out;
        }

        ndl->ndl_node->nd_state   = LST_NODE_ACTIVE;
        ndl->ndl_node->nd_timeout = console_session.ses_timeout;

        if (grp->grp_userland == 0)
                grp->grp_userland = 1;

        strcpy(jrep->join_session, console_session.ses_name);
        jrep->join_timeout = console_session.ses_timeout;
        jrep->join_status  = 0;

out:
        if (grp != NULL)
                lstcon_group_put(grp);

        mutex_up(&console_session.ses_mutex);

        return rc;
}

srpc_service_t lstcon_acceptor_service =
{
        .sv_name        = "join session",
        .sv_handler     = lstcon_acceptor_handle,
        .sv_bulk_ready  = NULL,
        .sv_id          = SRPC_SERVICE_JOIN,
        .sv_concur      = SFW_SERVICE_CONCURRENCY,
};

extern int lstcon_ioctl_entry(unsigned int cmd, struct libcfs_ioctl_data *data);

DECLARE_IOCTL_HANDLER(lstcon_ioctl_handler, lstcon_ioctl_entry);

/* initialize console */
int
lstcon_console_init(void)
{
        int     i;
        int     n;
        int     rc;

        memset(&console_session, 0, sizeof(lstcon_session_t));

        console_session.ses_id      = LST_INVALID_SID;
        console_session.ses_state   = LST_SESSION_NONE;
        console_session.ses_timeout = 0;
        console_session.ses_force   = 0;
        console_session.ses_expired = 0;
        console_session.ses_laststamp = cfs_time_current_sec();   

        init_mutex(&console_session.ses_mutex);

        CFS_INIT_LIST_HEAD(&console_session.ses_ndl_list);
        CFS_INIT_LIST_HEAD(&console_session.ses_grp_list);
        CFS_INIT_LIST_HEAD(&console_session.ses_bat_list);
        CFS_INIT_LIST_HEAD(&console_session.ses_trans_list);

        LIBCFS_ALLOC(console_session.ses_ndl_hash,
                     sizeof(struct list_head) * LST_GLOBAL_HASHSIZE);
        if (console_session.ses_ndl_hash == NULL)
                return -ENOMEM;

        for (i = 0; i < LST_GLOBAL_HASHSIZE; i++)
                CFS_INIT_LIST_HEAD(&console_session.ses_ndl_hash[i]);

        rc = srpc_add_service(&lstcon_acceptor_service);
        LASSERT (rc != -EBUSY);
        if (rc != 0) {
                LIBCFS_FREE(console_session.ses_ndl_hash,
                            sizeof(struct list_head) * LST_GLOBAL_HASHSIZE);
                return rc;
        }

        n = srpc_service_add_buffers(&lstcon_acceptor_service, SFW_POST_BUFFERS);
        if (n != SFW_POST_BUFFERS) {
                rc = -ENOMEM;
                goto out;
        }

        rc = libcfs_register_ioctl(&lstcon_ioctl_handler);

        if (rc == 0) {
                lstcon_rpc_module_init();
                return 0;
        }

out:
        srpc_shutdown_service(&lstcon_acceptor_service);
        srpc_remove_service(&lstcon_acceptor_service);

        LIBCFS_FREE(console_session.ses_ndl_hash,
                    sizeof(struct list_head) * LST_GLOBAL_HASHSIZE);

        srpc_wait_service_shutdown(&lstcon_acceptor_service);

        return rc;
}

int
lstcon_console_fini(void)
{
        int     i;

        mutex_down(&console_session.ses_mutex);

        libcfs_deregister_ioctl(&lstcon_ioctl_handler);

        srpc_shutdown_service(&lstcon_acceptor_service);
        srpc_remove_service(&lstcon_acceptor_service);

        if (console_session.ses_state != LST_SESSION_NONE) 
                lstcon_session_end();

        lstcon_rpc_module_fini();

        mutex_up(&console_session.ses_mutex);

        LASSERT (list_empty(&console_session.ses_ndl_list));
        LASSERT (list_empty(&console_session.ses_grp_list));
        LASSERT (list_empty(&console_session.ses_bat_list));
        LASSERT (list_empty(&console_session.ses_trans_list));

        for (i = 0; i < LST_NODE_HASHSIZE; i++) {
                LASSERT (list_empty(&console_session.ses_ndl_hash[i]));
        }

        LIBCFS_FREE(console_session.ses_ndl_hash,
                    sizeof(struct list_head) * LST_GLOBAL_HASHSIZE);

        srpc_wait_service_shutdown(&lstcon_acceptor_service);

        return 0;
}

#endif