async_sess.c

Go to the documentation of this file.

/*
 * Copyright (c) 2010 Jakub Jermar
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <async_sess.h>
#include <fibril_synch.h>
#include <adt/list.h>
#include <adt/hash_table.h>
#include <malloc.h>
#include <errno.h>
#include <assert.h>
#include <async.h>
#include "private/async_sess.h"

typedef struct {
        link_t sess_link;       
        link_t global_link;     
        int data_phone;         
} conn_node_t;

static fibril_mutex_t async_sess_mutex;

static LIST_INITIALIZE(inactive_conn_head);

static LIST_INITIALIZE(session_list_head);

static FIBRIL_CONDVAR_INITIALIZE(avail_phone_cv);

void __async_sess_init(void)
{
        fibril_mutex_initialize(&async_sess_mutex);
        list_initialize(&inactive_conn_head);
        list_initialize(&session_list_head);
}

void async_session_create(async_sess_t *sess, int phone, sysarg_t arg1)
{
        sess->sess_phone = phone;
        sess->connect_arg1 = arg1;
        list_initialize(&sess->conn_head);
        
        /* Add to list of sessions. */
        fibril_mutex_lock(&async_sess_mutex);
        list_append(&sess->sess_link, &session_list_head);
        fibril_mutex_unlock(&async_sess_mutex);
}

void async_session_destroy(async_sess_t *sess)
{
        conn_node_t *conn;

        /* Remove from list of sessions. */
        fibril_mutex_lock(&async_sess_mutex);
        list_remove(&sess->sess_link);
        fibril_mutex_unlock(&async_sess_mutex);

        /* We did not connect the phone so we do not hang it up either. */
        sess->sess_phone = -1;

        /* Tear down all data connections. */
        while (!list_empty(&sess->conn_head)) {
                conn = list_get_instance(sess->conn_head.next, conn_node_t,
                    sess_link);

                list_remove(&conn->sess_link);
                list_remove(&conn->global_link);
                
                async_hangup(conn->data_phone);
                free(conn);
        }
        
        fibril_condvar_broadcast(&avail_phone_cv);
}

static void conn_node_initialize(conn_node_t *conn)
{
        link_initialize(&conn->sess_link);
        link_initialize(&conn->global_link);
        conn->data_phone = -1;
}

int async_exchange_begin(async_sess_t *sess)
{
        conn_node_t *conn;
        int data_phone;

        fibril_mutex_lock(&async_sess_mutex);

        if (!list_empty(&sess->conn_head)) {
                /*
                 * There are inactive connections in the session.
                 */
                conn = list_get_instance(sess->conn_head.next, conn_node_t,
                    sess_link);
                list_remove(&conn->sess_link);
                list_remove(&conn->global_link);
                
                data_phone = conn->data_phone;
                free(conn);
        } else {
                /*
                 * There are no available connections in the session.
                 * Make a one-time attempt to connect a new data phone.
                 */
retry:
                data_phone = async_connect_me_to(sess->sess_phone,
                    sess->connect_arg1, 0, 0);
                if (data_phone >= 0) {
                        /* success, do nothing */
                } else if (!list_empty(&inactive_conn_head)) {
                        /*
                         * We did not manage to connect a new phone. But we can
                         * try to close some of the currently inactive
                         * connections in other sessions and try again.
                         */
                        conn = list_get_instance(inactive_conn_head.next,
                            conn_node_t, global_link);
                        list_remove(&conn->global_link);
                        list_remove(&conn->sess_link);
                        data_phone = conn->data_phone;
                        free(conn);
                        async_hangup(data_phone);
                        goto retry;
                } else {
                        /*
                         * Wait for a phone to become available.
                         */
                        fibril_condvar_wait(&avail_phone_cv, &async_sess_mutex);
                        goto retry;
                }
        }

        fibril_mutex_unlock(&async_sess_mutex);
        return data_phone;
}

void async_exchange_end(async_sess_t *sess, int data_phone)
{
        conn_node_t *conn;

        fibril_mutex_lock(&async_sess_mutex);
        fibril_condvar_signal(&avail_phone_cv);
        conn = (conn_node_t *) malloc(sizeof(conn_node_t));
        if (!conn) {
                /*
                 * Being unable to remember the connected data phone here
                 * means that we simply hang up.
                 */
                async_hangup(data_phone);
                fibril_mutex_unlock(&async_sess_mutex);
                return;
        }

        conn_node_initialize(conn);
        conn->data_phone = data_phone;
        list_append(&conn->sess_link, &sess->conn_head);
        list_append(&conn->global_link, &inactive_conn_head);
        fibril_mutex_unlock(&async_sess_mutex);
}

---