mars/mars_client.c

708 lines
19 KiB
C
Raw Normal View History

2011-02-23 20:48:06 +00:00
// (c) 2010 Thomas Schoebel-Theuer / 1&1 Internet AG
// Client brick (just for demonstration)
//#define BRICK_DEBUGGING
//#define MARS_DEBUGGING
//#define IO_DEBUGGING
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/string.h>
#include <linux/kthread.h>
#include "mars.h"
///////////////////////// own type definitions ////////////////////////
#include "mars_client.h"
///////////////////////// own helper functions ////////////////////////
static int thread_count = 0;
static void _kill_thread(struct client_threadinfo *ti)
{
2011-08-31 11:42:04 +00:00
if (ti->thread) {
2011-08-25 10:16:32 +00:00
MARS_INF("stopping thread...\n");
2011-02-23 20:48:06 +00:00
kthread_stop(ti->thread);
2011-09-02 12:17:40 +00:00
put_task_struct(ti->thread);
2011-05-26 14:32:32 +00:00
ti->thread = NULL;
2011-02-23 20:48:06 +00:00
}
}
2011-08-31 11:42:04 +00:00
static void _kill_socket(struct client_output *output)
{
if (mars_socket_is_alive(&output->socket)) {
2011-08-31 11:42:04 +00:00
MARS_DBG("shutdown socket\n");
mars_shutdown_socket(&output->socket);
2011-08-31 11:42:04 +00:00
}
_kill_thread(&output->receiver);
MARS_DBG("close socket\n");
mars_put_socket(&output->socket);
2011-08-31 11:42:04 +00:00
}
2011-03-07 05:55:10 +00:00
static int _request_info(struct client_output *output)
{
struct mars_cmd cmd = {
.cmd_code = CMD_GETINFO,
};
int status;
MARS_DBG("\n");
status = mars_send_struct(&output->socket, &cmd, mars_cmd_meta);
2011-03-07 05:55:10 +00:00
if (unlikely(status < 0)) {
MARS_DBG("send of getinfo failed, status = %d\n", status);
}
return status;
}
2011-08-31 11:42:04 +00:00
static int receiver_thread(void *data);
2011-02-23 20:48:06 +00:00
static int _connect(struct client_output *output, const char *str)
{
struct sockaddr_storage sockaddr = {};
int status;
2011-08-31 11:42:04 +00:00
if (unlikely(!output->path)) {
2011-08-12 11:09:48 +00:00
output->path = brick_strdup(str);
2011-02-27 14:17:58 +00:00
status = -ENOMEM;
2011-03-04 15:14:20 +00:00
if (!output->path) {
MARS_DBG("no mem\n");
2011-02-23 20:48:06 +00:00
goto done;
2011-03-04 15:14:20 +00:00
}
2011-02-27 14:17:58 +00:00
status = -EINVAL;
2011-03-03 09:02:10 +00:00
output->host = strchr(output->path, '@');
if (!output->host) {
2011-08-12 11:09:48 +00:00
brick_string_free(output->path);
2011-03-03 09:02:10 +00:00
output->path = NULL;
MARS_ERR("parameter string '%s' contains no remote specifier with '@'-syntax\n", str);
2011-02-23 20:48:06 +00:00
goto done;
}
2011-03-03 09:02:10 +00:00
*output->host++ = '\0';
2011-02-23 20:48:06 +00:00
}
status = mars_create_sockaddr(&sockaddr, output->host);
2011-03-04 15:14:20 +00:00
if (unlikely(status < 0)) {
MARS_DBG("no sockaddr, status = %d\n", status);
2011-02-23 20:48:06 +00:00
goto done;
2011-03-04 15:14:20 +00:00
}
2011-02-23 20:48:06 +00:00
status = mars_create_socket(&output->socket, &sockaddr, false);
if (unlikely(status < 0)) {
2011-03-04 15:14:20 +00:00
MARS_DBG("no socket, status = %d\n", status);
goto really_done;
2011-02-23 20:48:06 +00:00
}
output->socket.s_shutdown_on_err = true;
2011-02-23 20:48:06 +00:00
2011-08-31 11:42:04 +00:00
output->receiver.thread = kthread_create(receiver_thread, output, "mars_receiver%d", thread_count++);
if (unlikely(IS_ERR(output->receiver.thread))) {
status = PTR_ERR(output->receiver.thread);
MARS_ERR("cannot start receiver thread, status = %d\n", status);
output->receiver.thread = NULL;
output->receiver.terminated = true;
goto done;
}
2011-09-02 12:17:40 +00:00
get_task_struct(output->receiver.thread);
2011-08-31 11:42:04 +00:00
wake_up_process(output->receiver.thread);
2011-02-23 20:48:06 +00:00
{
struct mars_cmd cmd = {
.cmd_code = CMD_CONNECT,
.cmd_str1 = output->path,
};
status = mars_send_struct(&output->socket, &cmd, mars_cmd_meta);
2011-03-04 15:14:20 +00:00
if (unlikely(status < 0)) {
MARS_DBG("send of connect failed, status = %d\n", status);
2011-02-23 20:48:06 +00:00
goto done;
2011-03-04 15:14:20 +00:00
}
2011-02-23 20:48:06 +00:00
}
if (status >= 0) {
2011-03-07 05:55:10 +00:00
status = _request_info(output);
2011-02-23 20:48:06 +00:00
}
done:
if (status < 0) {
MARS_INF("cannot connect to remote host '%s' (status = %d) -- retrying\n", output->host ? output->host : "NULL", status);
_kill_socket(output);
}
2011-03-04 15:14:20 +00:00
really_done:
2011-02-23 20:48:06 +00:00
return status;
}
////////////////// own brick / input / output operations //////////////////
static int client_get_info(struct client_output *output, struct mars_info *info)
{
int status;
2011-03-07 05:55:10 +00:00
output->got_info = false;
output->get_info = true;
wake_up_interruptible(&output->event);
2011-02-23 20:48:06 +00:00
wait_event_interruptible_timeout(output->info_event, output->got_info, 60 * HZ);
status = -EIO;
if (output->got_info && info) {
memcpy(info, &output->info, sizeof(*info));
status = 0;
}
//done:
return status;
}
static int client_ref_get(struct client_output *output, struct mref_object *mref)
{
2011-03-22 14:36:26 +00:00
#if 1
2011-02-23 20:48:06 +00:00
/* Limit transfers to page boundaries.
* Currently, this is more restrictive than necessary.
* TODO: improve performance by doing better when possible.
* This needs help from the server in some efficient way.
*/
2011-03-22 14:36:26 +00:00
int maxlen = PAGE_SIZE - (mref->ref_pos & (PAGE_SIZE-1));
2011-02-23 20:48:06 +00:00
if (mref->ref_len > maxlen)
mref->ref_len = maxlen;
2011-03-22 14:36:26 +00:00
#endif
2011-02-23 20:48:06 +00:00
2011-03-22 14:36:26 +00:00
_CHECK_ATOMIC(&mref->ref_count, !=, 0);
2011-02-23 20:48:06 +00:00
if (!mref->ref_data) { // buffered IO
struct client_mref_aspect *mref_a = client_mref_get_aspect(output->brick, mref);
2011-02-23 20:48:06 +00:00
if (!mref_a)
return -EILSEQ;
mref->ref_data = brick_block_alloc(mref->ref_pos, (mref_a->alloc_len = mref->ref_len));
2011-02-23 20:48:06 +00:00
if (!mref->ref_data)
return -ENOMEM;
mref_a->do_dealloc = true;
mref->ref_flags = 0;
}
atomic_inc(&mref->ref_count);
return 0;
}
static void client_ref_put(struct client_output *output, struct mref_object *mref)
{
struct client_mref_aspect *mref_a;
CHECK_ATOMIC(&mref->ref_count, 1);
if (!atomic_dec_and_test(&mref->ref_count))
return;
mref_a = client_mref_get_aspect(output->brick, mref);
2011-02-23 20:48:06 +00:00
if (mref_a && mref_a->do_dealloc) {
brick_block_free(mref->ref_data, mref_a->alloc_len);
2011-02-23 20:48:06 +00:00
}
client_free_mref(mref);
}
static void client_ref_io(struct client_output *output, struct mref_object *mref)
{
struct client_mref_aspect *mref_a;
2011-03-30 12:02:50 +00:00
int hash_index;
2011-02-23 20:48:06 +00:00
unsigned long flags;
int error = -EINVAL;
mref_a = client_mref_get_aspect(output->brick, mref);
2011-02-23 20:48:06 +00:00
if (unlikely(!mref_a)) {
goto error;
}
2011-03-29 14:40:40 +00:00
while (output->brick->max_flying > 0 && atomic_read(&output->fly_count) > output->brick->max_flying) {
2011-03-30 12:02:50 +00:00
MARS_IO("sleeping request pos = %lld len = %d rw = %d (flying = %d)\n", mref->ref_pos, mref->ref_len, mref->ref_rw, atomic_read(&output->fly_count));
#ifdef IO_DEBUGGING
msleep(3000);
#else
2011-03-29 14:40:40 +00:00
msleep(1000 * 2 / HZ);
2011-03-30 12:02:50 +00:00
#endif
2011-03-29 14:40:40 +00:00
}
atomic_inc(&output->fly_count);
2011-02-23 20:48:06 +00:00
atomic_inc(&mref->ref_count);
traced_lock(&output->lock, flags);
2012-01-23 12:39:08 +00:00
mref_a->submit_jiffies = jiffies;
2011-03-30 12:02:50 +00:00
mref->ref_id = ++output->last_id;
2011-02-23 20:48:06 +00:00
list_add_tail(&mref_a->io_head, &output->mref_list);
traced_unlock(&output->lock, flags);
2011-03-30 12:02:50 +00:00
hash_index = mref->ref_id % CLIENT_HASH_MAX;
traced_lock(&output->hash_lock[hash_index], flags);
list_add_tail(&mref_a->hash_head, &output->hash_table[hash_index]);
traced_unlock(&output->hash_lock[hash_index], flags);
MARS_IO("added request id = %d pos = %lld len = %d rw = %d (flying = %d)\n", mref->ref_id, mref->ref_pos, mref->ref_len, mref->ref_rw, atomic_read(&output->fly_count));
2011-02-23 20:48:06 +00:00
wake_up_interruptible(&output->event);
return;
error:
MARS_ERR("IO error = %d\n", error);
SIMPLE_CALLBACK(mref, error);
2011-02-23 20:48:06 +00:00
client_ref_put(output, mref);
}
2011-05-26 14:32:32 +00:00
static
int receiver_thread(void *data)
2011-02-23 20:48:06 +00:00
{
struct client_output *output = data;
int status = 0;
while (status >= 0 && mars_socket_is_alive(&output->socket) && !kthread_should_stop()) {
2011-02-23 20:48:06 +00:00
struct mars_cmd cmd = {};
struct list_head *tmp;
struct client_mref_aspect *mref_a = NULL;
struct mref_object *mref = NULL;
unsigned long flags;
status = mars_recv_struct(&output->socket, &cmd, mars_cmd_meta);
2011-03-30 12:02:50 +00:00
MARS_IO("got cmd = %d status = %d\n", cmd.cmd_code, status);
2011-02-23 20:48:06 +00:00
if (status < 0)
goto done;
switch (cmd.cmd_code) {
2012-01-17 14:37:14 +00:00
case CMD_NOTIFY:
mars_trigger();
break;
2011-02-23 20:48:06 +00:00
case CMD_CONNECT:
if (cmd.cmd_int1 < 0) {
status = cmd.cmd_int1;
2011-02-27 14:17:58 +00:00
MARS_ERR("at remote side: brick connect failed, remote status = %d\n", status);
2011-02-23 20:48:06 +00:00
goto done;
}
break;
case CMD_CB:
2011-03-30 12:02:50 +00:00
{
2011-05-19 11:36:00 +00:00
int hash_index = cmd.cmd_int1 % CLIENT_HASH_MAX;
2011-03-30 12:02:50 +00:00
traced_lock(&output->hash_lock[hash_index], flags);
for (tmp = output->hash_table[hash_index].next; tmp != &output->hash_table[hash_index]; tmp = tmp->next) {
2011-07-01 14:07:56 +00:00
struct mref_object *tmp_mref;
2011-03-30 12:02:50 +00:00
mref_a = container_of(tmp, struct client_mref_aspect, hash_head);
2011-07-01 14:07:56 +00:00
tmp_mref = mref_a->object;
if (unlikely(!tmp_mref)) {
2011-08-12 12:25:10 +00:00
traced_unlock(&output->hash_lock[hash_index], flags);
2011-07-01 14:07:56 +00:00
MARS_ERR("bad internal mref pointer\n");
status = -EBADR;
goto done;
}
if (tmp_mref->ref_id == cmd.cmd_int1) {
mref = tmp_mref;
2011-02-23 20:48:06 +00:00
break;
}
}
2011-03-30 12:02:50 +00:00
traced_unlock(&output->hash_lock[hash_index], flags);
2011-02-23 20:48:06 +00:00
if (!mref) {
2011-02-27 14:17:58 +00:00
MARS_ERR("got unknown id = %d for callback\n", cmd.cmd_int1);
2011-02-23 20:48:06 +00:00
status = -EBADR;
goto done;
}
2011-03-30 12:02:50 +00:00
MARS_IO("got callback id = %d, old pos = %lld len = %d rw = %d\n", mref->ref_id, mref->ref_pos, mref->ref_len, mref->ref_rw);
status = mars_recv_cb(&output->socket, mref);
2011-03-30 12:02:50 +00:00
MARS_IO("new status = %d, pos = %lld len = %d rw = %d\n", status, mref->ref_pos, mref->ref_len, mref->ref_rw);
2011-02-23 20:48:06 +00:00
if (status < 0) {
MARS_WRN("interrupted data transfer during callback, status = %d\n", status);
2011-02-23 20:48:06 +00:00
goto done;
}
2012-01-23 12:39:08 +00:00
traced_lock(&output->hash_lock[hash_index], flags);
list_del_init(&mref_a->hash_head);
traced_unlock(&output->hash_lock[hash_index], flags);
2011-02-23 20:48:06 +00:00
traced_lock(&output->lock, flags);
list_del_init(&mref_a->io_head);
traced_unlock(&output->lock, flags);
2011-03-29 14:40:40 +00:00
atomic_dec(&output->fly_count);
SIMPLE_CALLBACK(mref, 0);
2011-02-23 20:48:06 +00:00
client_ref_put(output, mref);
break;
2011-03-30 12:02:50 +00:00
}
2011-02-23 20:48:06 +00:00
case CMD_GETINFO:
status = mars_recv_struct(&output->socket, &output->info, mars_info_meta);
2011-02-23 20:48:06 +00:00
if (status < 0) {
MARS_WRN("got bad info from remote side, status = %d\n", status);
2011-02-23 20:48:06 +00:00
goto done;
}
output->got_info = true;
wake_up_interruptible(&output->info_event);
break;
default:
2011-02-27 14:17:58 +00:00
MARS_ERR("got bad command %d from remote side, terminating.\n", cmd.cmd_code);
2011-02-23 20:48:06 +00:00
status = -EBADR;
goto done;
}
2011-08-12 12:25:10 +00:00
done:
brick_string_free(cmd.cmd_str1);
2011-02-23 20:48:06 +00:00
}
2011-03-03 18:23:34 +00:00
if (status < 0) {
2011-09-02 12:17:40 +00:00
MARS_WRN("receiver thread terminated with status = %d\n", status);
2011-03-03 18:23:34 +00:00
}
2011-08-31 11:42:04 +00:00
mars_shutdown_socket(&output->socket);
2011-03-03 18:23:34 +00:00
output->receiver.terminated = true;
wake_up_interruptible(&output->receiver.run_event);
2011-02-23 20:48:06 +00:00
return status;
}
static
void _do_resubmit(struct client_output *output)
{
if (!list_empty(&output->wait_list)) {
struct list_head *first = output->wait_list.next;
struct list_head *last = output->wait_list.prev;
struct list_head *old_start = output->mref_list.next;
#define list_connect __list_del // the original routine has a misleading name: in reality it is more general
list_connect(&output->mref_list, first);
list_connect(last, old_start);
INIT_LIST_HEAD(&output->wait_list);
MARS_IO("done re-submit %p %p\n", first, last);
}
}
2012-01-23 12:39:08 +00:00
static
void _do_timeout(struct client_output *output, struct list_head *anchor, bool force)
{
struct client_brick *brick = output->brick;
while (!list_empty(anchor)) {
struct list_head *tmp;
struct client_mref_aspect *mref_a;
struct mref_object *mref;
int hash_index;
unsigned long flags;
traced_lock(&output->lock, flags);
tmp = anchor->next;
traced_unlock(&output->lock, flags);
mref_a = container_of(tmp, struct client_mref_aspect, io_head);
mref = mref_a->object;
if (!force &&
(brick->io_timeout <= 0 || !time_is_before_jiffies(mref_a->submit_jiffies + brick->io_timeout * HZ))) {
break;
}
MARS_DBG("signalling IO error at pos = %lld len = %d\n", mref->ref_pos, mref->ref_len);
atomic_inc(&output->timeout_count);
hash_index = mref->ref_id % CLIENT_HASH_MAX;
traced_lock(&output->hash_lock[hash_index], flags);
list_del_init(&mref_a->hash_head);
traced_unlock(&output->hash_lock[hash_index], flags);
traced_lock(&output->lock, flags);
list_del_init(&mref_a->io_head);
traced_unlock(&output->lock, flags);
SIMPLE_CALLBACK(mref, -ENOTCONN);
client_ref_put(output, mref);
atomic_dec(&output->fly_count);
}
}
2011-02-23 20:48:06 +00:00
static int sender_thread(void *data)
{
struct client_output *output = data;
struct client_brick *brick = output->brick;
unsigned long flags;
bool do_kill = false;
2011-02-23 20:48:06 +00:00
int status = 0;
2011-05-26 14:32:32 +00:00
output->receiver.restart_count = 0;
2011-02-23 20:48:06 +00:00
while (!kthread_should_stop()) {
2012-01-23 12:39:08 +00:00
struct list_head *tmp = NULL;
2011-02-23 20:48:06 +00:00
struct client_mref_aspect *mref_a;
2011-03-30 12:02:50 +00:00
struct mref_object *mref;
2011-02-23 20:48:06 +00:00
bool do_resubmit = false;
if (unlikely(!mars_socket_is_alive(&output->socket))) {
if (do_kill) {
do_kill = false;
_kill_socket(output);
}
2012-01-23 12:39:08 +00:00
2011-02-23 20:48:06 +00:00
status = _connect(output, brick->brick_name);
2011-03-30 12:02:50 +00:00
MARS_IO("connect status = %d\n", status);
2011-02-23 20:48:06 +00:00
if (unlikely(status < 0)) {
2012-01-23 12:39:08 +00:00
_do_timeout(output, &output->wait_list, false);
_do_timeout(output, &output->mref_list, false);
msleep(3000);
2011-02-23 20:48:06 +00:00
continue;
}
do_kill = true;
2011-02-23 20:48:06 +00:00
do_resubmit = true;
}
if (do_resubmit) {
/* Re-Submit any waiting requests
*/
2011-03-30 12:02:50 +00:00
MARS_IO("re-submit\n");
2011-02-23 20:48:06 +00:00
traced_lock(&output->lock, flags);
_do_resubmit(output);
2011-02-23 20:48:06 +00:00
traced_unlock(&output->lock, flags);
}
wait_event_interruptible_timeout(output->event, !list_empty(&output->mref_list) || output->get_info || kthread_should_stop(), 1 * HZ);
2011-02-23 20:48:06 +00:00
2011-03-07 05:55:10 +00:00
if (output->get_info) {
status = _request_info(output);
if (status >= 0) {
output->get_info = false;
2012-01-23 12:39:08 +00:00
} else {
MARS_WRN("cannot get info, status = %d\n", status);
msleep(1000);
2011-03-07 05:55:10 +00:00
}
}
2011-02-23 20:48:06 +00:00
if (list_empty(&output->mref_list))
continue;
traced_lock(&output->lock, flags);
tmp = output->mref_list.next;
traced_unlock(&output->lock, flags);
mref_a = container_of(tmp, struct client_mref_aspect, io_head);
2011-03-30 12:02:50 +00:00
mref = mref_a->object;
2011-02-23 20:48:06 +00:00
2011-03-30 12:02:50 +00:00
MARS_IO("sending mref, id = %d pos = %lld len = %d rw = %d\n", mref->ref_id, mref->ref_pos, mref->ref_len, mref->ref_rw);
status = mars_send_mref(&output->socket, mref);
2011-03-30 12:02:50 +00:00
MARS_IO("status = %d\n", status);
2011-02-23 20:48:06 +00:00
if (unlikely(status < 0)) {
// retry submission on next occasion..
2011-09-02 12:17:40 +00:00
MARS_WRN("sending failed, status = %d\n", status);
2011-02-23 20:48:06 +00:00
if (do_kill) {
do_kill = false;
_kill_socket(output);
}
2011-02-23 20:48:06 +00:00
continue;
}
2012-01-23 12:39:08 +00:00
// all ok, remember in-flight mrefs
traced_lock(&output->lock, flags);
list_del(tmp);
list_add(tmp, &output->wait_list);
traced_unlock(&output->lock, flags);
2011-02-23 20:48:06 +00:00
}
//done:
2011-08-31 11:42:04 +00:00
if (status < 0) {
2011-09-02 12:17:40 +00:00
MARS_WRN("sender thread terminated with status = %d\n", status);
2011-08-31 11:42:04 +00:00
}
2011-02-23 20:48:06 +00:00
if (do_kill) {
_kill_socket(output);
}
2011-02-23 20:48:06 +00:00
/* Signal error on all pending IO requests.
* We have no other chance (except probably delaying
2012-01-23 12:39:08 +00:00
* this until destruction which is probably not what
* we want).
*/
2012-01-23 12:39:08 +00:00
_do_timeout(output, &output->wait_list, true);
_do_timeout(output, &output->mref_list, true);
2011-03-03 18:23:34 +00:00
output->sender.terminated = true;
wake_up_interruptible(&output->sender.run_event);
MARS_DBG("sender terminated\n");
2011-02-23 20:48:06 +00:00
return status;
}
static int client_switch(struct client_brick *brick)
{
struct client_output *output = brick->outputs[0];
int status = 0;
if (brick->power.button) {
mars_power_led_off((void*)brick, false);
2011-03-03 18:23:34 +00:00
if (output->sender.terminated) {
output->sender.terminated = false;
output->sender.thread = kthread_create(sender_thread, output, "mars_sender%d", thread_count++);
if (unlikely(IS_ERR(output->sender.thread))) {
status = PTR_ERR(output->sender.thread);
MARS_ERR("cannot start sender thread, status = %d\n", status);
output->sender.thread = NULL;
output->sender.terminated = true;
goto done;
}
2011-02-23 20:48:06 +00:00
}
2011-09-02 12:17:40 +00:00
get_task_struct(output->sender.thread);
2011-02-23 20:48:06 +00:00
wake_up_process(output->sender.thread);
2011-03-03 18:23:34 +00:00
if (!output->sender.terminated) {
mars_power_led_on((void*)brick, true);
}
2011-02-23 20:48:06 +00:00
} else {
mars_power_led_on((void*)brick, false);
_kill_thread(&output->sender);
2011-03-03 18:23:34 +00:00
wait_event_interruptible_timeout(output->sender.run_event, output->sender.terminated, 10 * HZ);
if (output->sender.terminated) {
mars_power_led_off((void*)brick, !output->sender.thread);
}
2011-02-23 20:48:06 +00:00
}
done:
return status;
}
//////////////// informational / statistics ///////////////
static
char *client_statistics(struct client_brick *brick, int verbose)
{
struct client_output *output = brick->outputs[0];
2012-01-23 12:39:08 +00:00
char *res = brick_string_alloc(1024);
if (!res)
return NULL;
2012-01-23 12:39:08 +00:00
snprintf(res, 1024,
"#%d socket max_flying = %d io_timeout = %d | timeout_count = %d fly_count = %d\n",
output->socket.s_debug_nr, brick->max_flying, brick->io_timeout,
atomic_read(&output->timeout_count), atomic_read(&output->fly_count));
return res;
}
static
void client_reset_statistics(struct client_brick *brick)
{
2012-01-23 12:39:08 +00:00
struct client_output *output = brick->outputs[0];
atomic_set(&output->timeout_count, 0);
}
2011-02-23 20:48:06 +00:00
//////////////// object / aspect constructors / destructors ///////////////
static int client_mref_aspect_init_fn(struct generic_aspect *_ini)
2011-02-23 20:48:06 +00:00
{
struct client_mref_aspect *ini = (void*)_ini;
INIT_LIST_HEAD(&ini->io_head);
2011-03-30 12:02:50 +00:00
INIT_LIST_HEAD(&ini->hash_head);
2011-02-23 20:48:06 +00:00
return 0;
}
static void client_mref_aspect_exit_fn(struct generic_aspect *_ini)
2011-02-23 20:48:06 +00:00
{
struct client_mref_aspect *ini = (void*)_ini;
2011-03-30 12:02:50 +00:00
CHECK_HEAD_EMPTY(&ini->io_head);
CHECK_HEAD_EMPTY(&ini->hash_head);
2011-02-23 20:48:06 +00:00
}
MARS_MAKE_STATICS(client);
////////////////////// brick constructors / destructors ////////////////////
static int client_brick_construct(struct client_brick *brick)
{
return 0;
}
static int client_output_construct(struct client_output *output)
{
2011-03-30 12:02:50 +00:00
int i;
for (i = 0; i < CLIENT_HASH_MAX; i++) {
spin_lock_init(&output->hash_lock[i]);
INIT_LIST_HEAD(&output->hash_table[i]);
}
2011-02-23 20:48:06 +00:00
spin_lock_init(&output->lock);
INIT_LIST_HEAD(&output->mref_list);
INIT_LIST_HEAD(&output->wait_list);
init_waitqueue_head(&output->event);
2011-03-03 18:23:34 +00:00
init_waitqueue_head(&output->sender.run_event);
init_waitqueue_head(&output->receiver.run_event);
2011-02-23 20:48:06 +00:00
init_waitqueue_head(&output->info_event);
2011-03-03 18:23:34 +00:00
output->sender.terminated = true;
output->receiver.terminated = true;
2011-02-23 20:48:06 +00:00
return 0;
}
static int client_output_destruct(struct client_output *output)
{
2011-03-03 09:02:10 +00:00
if (output->path) {
2011-08-12 11:09:48 +00:00
brick_string_free(output->path);
2011-03-03 09:02:10 +00:00
output->path = NULL;
}
2011-02-23 20:48:06 +00:00
return 0;
}
///////////////////////// static structs ////////////////////////
static struct client_brick_ops client_brick_ops = {
.brick_switch = client_switch,
.brick_statistics = client_statistics,
.reset_statistics = client_reset_statistics,
2011-02-23 20:48:06 +00:00
};
static struct client_output_ops client_output_ops = {
.mars_get_info = client_get_info,
.mref_get = client_ref_get,
.mref_put = client_ref_put,
.mref_io = client_ref_io,
};
const struct client_input_type client_input_type = {
.type_name = "client_input",
.input_size = sizeof(struct client_input),
};
static const struct client_input_type *client_input_types[] = {
&client_input_type,
};
const struct client_output_type client_output_type = {
.type_name = "client_output",
.output_size = sizeof(struct client_output),
.master_ops = &client_output_ops,
.output_construct = &client_output_construct,
.output_destruct = &client_output_destruct,
};
static const struct client_output_type *client_output_types[] = {
&client_output_type,
};
const struct client_brick_type client_brick_type = {
.type_name = "client_brick",
.brick_size = sizeof(struct client_brick),
.max_inputs = 0,
.max_outputs = 1,
.master_ops = &client_brick_ops,
.aspect_types = client_aspect_types,
2011-02-23 20:48:06 +00:00
.default_input_types = client_input_types,
.default_output_types = client_output_types,
.brick_construct = &client_brick_construct,
};
EXPORT_SYMBOL_GPL(client_brick_type);
////////////////// module init stuff /////////////////////////
2011-08-25 10:16:32 +00:00
int __init init_mars_client(void)
2011-02-23 20:48:06 +00:00
{
MARS_INF("init_client()\n");
2011-02-28 18:00:32 +00:00
_client_brick_type = (void*)&client_brick_type;
2011-02-23 20:48:06 +00:00
return client_register_brick_type();
}
2011-08-25 10:16:32 +00:00
void __exit exit_mars_client(void)
2011-02-23 20:48:06 +00:00
{
MARS_INF("exit_client()\n");
client_unregister_brick_type();
}
2011-08-25 10:16:32 +00:00
#ifndef CONFIG_MARS_HAVE_BIGMODULE
2011-02-23 20:48:06 +00:00
MODULE_DESCRIPTION("MARS client brick");
MODULE_AUTHOR("Thomas Schoebel-Theuer <tst@1und1.de>");
MODULE_LICENSE("GPL");
2011-08-25 10:16:32 +00:00
module_init(init_mars_client);
module_exit(exit_mars_client);
#endif