* vim:expandtab:shiftwidth=8:tabstop=8:
*
* Copyright (c) 2002 Cray Inc.
+ * Copyright (c) 2003 Cluster File Systems, Inc.
*
* This file is part of Lustre, http://www.lustre.org.
*
#include <stdio.h>
#include <stdarg.h>
#include <unistd.h>
-#include <syscall.h>
#include <procbridge.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <errno.h>
#include <timer.h>
-//#include <util/pqtimer.h>
#include <dispatch.h>
/* the following functions are stubs to satisfy the nal definition
without doing anything particularily useful*/
-static int nal_write(nal_cb_t *nal,
- void *private,
- user_ptr dst_addr,
- void *src_addr,
- ptl_size_t len)
+static ptl_err_t nal_write(nal_cb_t *nal,
+ void *private,
+ user_ptr dst_addr,
+ void *src_addr,
+ size_t len)
{
memcpy(dst_addr, src_addr, len);
- return 0;
+ return PTL_OK;
}
-static int nal_read(nal_cb_t * nal,
- void *private,
- void *dst_addr,
- user_ptr src_addr,
- size_t len)
+static ptl_err_t nal_read(nal_cb_t * nal,
+ void *private,
+ void *dst_addr,
+ user_ptr src_addr,
+ size_t len)
{
memcpy(dst_addr, src_addr, len);
- return 0;
+ return PTL_OK;
}
static void *nal_malloc(nal_cb_t *nal,
- ptl_size_t len)
+ size_t len)
{
void *buf = malloc(len);
return buf;
static void nal_free(nal_cb_t *nal,
void *buf,
- ptl_size_t len)
+ size_t len)
{
free(buf);
}
static void nal_cli(nal_cb_t *nal,
unsigned long *flags)
{
+ bridge b = (bridge) nal->nal_data;
+ procbridge p = (procbridge) b->local;
+
+ pthread_mutex_lock(&p->mutex);
}
static void nal_sti(nal_cb_t *nal,
unsigned long *flags)
{
+ bridge b = (bridge)nal->nal_data;
+ procbridge p = (procbridge) b->local;
+
+ pthread_mutex_unlock(&p->mutex);
}
+static void nal_callback(nal_cb_t *nal, void *private,
+ lib_eq_t *eq, ptl_event_t *ev)
+{
+ bridge b = (bridge)nal->nal_data;
+ procbridge p = (procbridge) b->local;
+
+ /* holding p->mutex */
+ if (eq->event_callback != NULL)
+ eq->event_callback(ev);
+
+ pthread_cond_broadcast(&p->cond);
+}
static int nal_dist(nal_cb_t *nal,
ptl_nid_t nid,
{
return 0;
}
-
-
-
-/* Function: data_from_api
- * Arguments: t: the nal state for this interface
- * Returns: whether to continue reading from the pipe
- *
- * data_from_api() reads data from the api side in response
- * to a select.
- *
- * We define data_failure() for syntactic convenience
- * of unix error reporting.
- */
-#define data_failure(operand,fd,buffer,length)\
- if(syscall(SYS_##operand,fd,buffer,length)!=length){\
- lib_fini(b->nal_cb);\
- return(0);\
- }
-static int data_from_api(void *arg)
+static void check_stopping(void *z)
{
- bridge b = arg;
- procbridge p=(procbridge)b->local;
- /* where are these two sizes derived from ??*/
- char arg_block[ 256 ];
- char ret_block[ 128 ];
- ptl_size_t arg_len,ret_len;
- int fd=p->to_lib[0];
- int index;
-
- data_failure(read,fd, &index, sizeof(index));
-
- if (index==PTL_FINI) {
- lib_fini(b->nal_cb);
- if (b->shutdown) (*b->shutdown)(b);
- syscall(SYS_write, p->from_lib[1],&b->alive,sizeof(b->alive));
-
- /* a heavy-handed but convenient way of shutting down
- the lower side thread */
- pthread_exit(0);
- }
-
- data_failure(read,fd, &arg_len, sizeof(arg_len));
- data_failure(read,fd, &ret_len, sizeof(ret_len));
- data_failure(read,fd, arg_block, arg_len);
-
- lib_dispatch(b->nal_cb, NULL, index, arg_block, ret_block);
-
- data_failure(write,p->from_lib[1],ret_block, ret_len);
- return(1);
-}
-#undef data_failure
-
-
-
-static void wakeup_topside(void *z)
-{
- bridge b=z;
- procbridge p=b->local;
+ bridge b = z;
+ procbridge p = b->local;
+ if ((p->nal_flags & NAL_FLAG_STOPPING) == 0)
+ return;
+
pthread_mutex_lock(&p->mutex);
+ p->nal_flags |= NAL_FLAG_STOPPED;
pthread_cond_broadcast(&p->cond);
pthread_mutex_unlock(&p->mutex);
+
+ pthread_exit(0);
}
* We define a limit macro to place a ceiling on limits
* for syntactic convenience
*/
-#define LIMIT(x,y,max)\
- if ((unsigned int)x > max) y = max;
-
extern int tcpnal_init(bridge);
nal_initialize nal_table[PTL_IFACE_MAX]={0,tcpnal_init,0};
void *nal_thread(void *z)
{
- bridge b=z;
+ nal_init_args_t *args = (nal_init_args_t *) z;
+ bridge b = args->nia_bridge;
procbridge p=b->local;
int rc;
- ptl_pid_t pid_request;
+ ptl_process_id_t process_id;
int nal_type;
- ptl_ni_limits_t desired;
- ptl_ni_limits_t actual;
b->nal_cb=(nal_cb_t *)malloc(sizeof(nal_cb_t));
b->nal_cb->nal_data=b;
b->nal_cb->cb_printf=nal_printf;
b->nal_cb->cb_cli=nal_cli;
b->nal_cb->cb_sti=nal_sti;
+ b->nal_cb->cb_callback=nal_callback;
b->nal_cb->cb_dist=nal_dist;
+ nal_type = args->nia_nal_type;
- register_io_handler(p->to_lib[0],READ_HANDLER,data_from_api,(void *)b);
-
- if(!(rc = syscall(SYS_read, p->to_lib[0], &pid_request, sizeof(pid_request))))
- perror("procbridge read from api");
- if(!(rc = syscall(SYS_read, p->to_lib[0], &desired, sizeof(ptl_ni_limits_t))))
- perror("procbridge read from api");
- if(!(rc = syscall(SYS_read, p->to_lib[0], &nal_type, sizeof(nal_type))))
- perror("procbridge read from api");
-
- actual = desired;
- LIMIT(desired.max_match_entries,actual.max_match_entries,MAX_MES);
- LIMIT(desired.max_mem_descriptors,actual.max_mem_descriptors,MAX_MDS);
- LIMIT(desired.max_event_queues,actual.max_event_queues,MAX_EQS);
- LIMIT(desired.max_atable_index,actual.max_atable_index,MAX_ACLS);
- LIMIT(desired.max_ptable_index,actual.max_ptable_index,MAX_PTLS);
-
- set_address(b,pid_request);
+ /* Wierd, but this sets b->nal_cb->ni.{nid,pid}, which lib_init() is
+ * about to do from the process_id passed to it...*/
+ set_address(b,args->nia_requested_pid);
+ process_id.pid = b->nal_cb->ni.pid;
+ process_id.nid = b->nal_cb->ni.nid;
+
if (nal_table[nal_type]) rc=(*nal_table[nal_type])(b);
/* initialize the generic 'library' level code */
- rc = lib_init(b->nal_cb,
- b->nal_cb->ni.nid,
- b->nal_cb->ni.pid,
- 10,
- actual.max_ptable_index,
- actual.max_atable_index);
+ rc = lib_init(b->nal_cb, process_id,
+ args->nia_requested_limits,
+ args->nia_actual_limits);
/*
* Whatever the initialization returned is passed back to the
* it is non-zero since something went wrong.
*/
/* this should perform error checking */
-#if 0
- write(p->from_lib[1], &actual, sizeof(ptl_ni_limits_t));
-#endif
- syscall(SYS_write, p->from_lib[1], &rc, sizeof(rc));
-
- if(!rc) {
+ pthread_mutex_lock(&p->mutex);
+ p->nal_flags |= (rc != PTL_OK) ? NAL_FLAG_STOPPED : NAL_FLAG_RUNNING;
+ pthread_cond_broadcast(&p->cond);
+ pthread_mutex_unlock(&p->mutex);
+
+ if (rc == PTL_OK) {
/* the thunk function is called each time the timer loop
performs an operation and returns to blocking mode. we
overload this function to inform the api side that
it may be interested in looking at the event queue */
- register_thunk(wakeup_topside,b);
+ register_thunk(check_stopping,b);
timer_loop();
}
return(0);
}
-#undef LIMIT
-
git://git.whamcloud.com / fs / lustre-release.git / blobdiff