int rtapi_exit(int module_id)
{
module_data *module;
int n;
if (rtapi_data == NULL) {
rtapi_print_msg(RTAPI_MSG_ERR,
"RTAPI: ERROR: exit called before init\n");
return -EINVAL;
}
rtapi_print_msg(RTAPI_MSG_DBG, "RTAPI: module %02d exiting\n", module_id);
/* validate module ID */
if ((module_id < 1) || (module_id > RTAPI_MAX_MODULES)) {
rtapi_print_msg(RTAPI_MSG_ERR, "RTAPI: ERROR: bad module id\n");
return -EINVAL;
}
/* get mutex */
rtapi_mutex_get(&(rtapi_data->mutex));
/* point to the module's data */
module = &(module_array[module_id]);
/* check module status */
if (module->state != USERSPACE) {
rtapi_print_msg(RTAPI_MSG_ERR,
"RTAPI: ERROR: not a userspace module\n");
rtapi_mutex_give(&(rtapi_data->mutex));
return -EINVAL;
}
/* clean up any mess left behind by the module */
for (n = 1; n <= RTAPI_MAX_SHMEMS; n++) {
if (test_bit(module_id, shmem_array[n].bitmap)) {
fprintf(stderr,
"ULAPI: WARNING: module '%s' failed to delete shmem %02d\n",
module->name, n);
shmem_delete(n, module_id);
}
}
for (n = 1; n <= RTAPI_MAX_FIFOS; n++) {
if ((fifo_array[n].reader == module_id) ||
(fifo_array[n].writer == module_id)) {
fprintf(stderr,
"ULAPI: WARNING: module '%s' failed to delete fifo %02d\n",
module->name, n);
fifo_delete(n, module_id);
}
}
/* update module data */
rtapi_print_msg(RTAPI_MSG_DBG, "RTAPI: module %02d exited, name = '%s'\n",
module_id, module->name);
module->state = NO_MODULE;
module->name[0] = '\0';
rtapi_data->ul_module_count--;
rtapi_mutex_give(&(rtapi_data->mutex));
nummods--;
if(nummods == 0)
{
rtai_free(RTAPI_KEY, rtapi_data);
rtapi_data = 0;
}
return 0;
}
int _rtapi_exit(int module_id) {
module_data *module;
int n;
if (rtapi_data == NULL) {
rtapi_print_msg(RTAPI_MSG_ERR,
"RTAPI:%d ERROR: exit called before init\n",
rtapi_instance);
return -EINVAL;
}
rtapi_print_msg(RTAPI_MSG_DBG, "RTAPI:%d module %02d exiting\n",
rtapi_instance,module_id);
/* validate module ID */
if ((module_id < 1) || (module_id > RTAPI_MAX_MODULES)) {
rtapi_print_msg(RTAPI_MSG_ERR, "RTAPI:%d ERROR: bad module id\n",
rtapi_instance);
return -EINVAL;
}
/* get mutex */
rtapi_mutex_get(&(rtapi_data->mutex));
/* point to the module's data */
module = &(module_array[module_id]);
/* check module status */
if (module->state != USERSPACE) {
rtapi_print_msg(RTAPI_MSG_ERR,
"RTAPI:%d ERROR: not a userspace module\n",
rtapi_instance);
rtapi_mutex_give(&(rtapi_data->mutex));
return -EINVAL;
}
/* clean up any mess left behind by the module */
for (n = 1; n <= RTAPI_MAX_SHMEMS; n++) {
if (rtapi_test_bit(module_id, shmem_array[n].bitmap)) {
rtapi_print_msg(RTAPI_MSG_WARN,
"ULAPI:%d WARNING: module '%s' failed to delete "
"shmem %02d\n", rtapi_instance,module->name, n);
// mark block as ready for delete, lock already held
shmem_array[n].magic = SHMEM_MAGIC_DEL_LOCKED;
_rtapi_shmem_delete(n, module_id);
}
}
/* update module data */
rtapi_print_msg(RTAPI_MSG_DBG, "RTAPI:%d module %02d exited, name = '%s'\n",
rtapi_instance, module_id, module->name);
module->state = NO_MODULE;
module->name[0] = '\0';
rtapi_data->ul_module_count--;
rtapi_mutex_give(&(rtapi_data->mutex));
return 0;
}
int _rtapi_task_delete(int task_id) {
task_data *task;
int retval = 0;
if(task_id < 0 || task_id >= RTAPI_MAX_TASKS) return -EINVAL;
task = &(task_array[task_id]);
/* validate task handle */
if (task->magic != TASK_MAGIC) // nothing to delete
return -EINVAL;
if (task->state != DELETE_LOCKED) // we don't already hold mutex
rtapi_mutex_get(&(rtapi_data->mutex));
#ifdef MODULE
if ((task->state == PERIODIC) || (task->state == FREERUN)) {
/* task is running, need to stop it */
rtapi_print_msg(RTAPI_MSG_WARN,
"RTAPI: WARNING: tried to delete task %02d while running\n",
task_id);
_rtapi_task_pause(task_id);
}
/* get rid of it */
rt_task_delete(ostask_array[task_id]);
/* free kernel memory */
kfree(ostask_array[task_id]);
/* update data */
task->prio = 0;
task->owner = 0;
task->taskcode = NULL;
ostask_array[task_id] = NULL;
rtapi_data->task_count--;
/* if no more tasks, stop the timer */
if (rtapi_data->task_count == 0) {
if (rtapi_data->timer_running != 0) {
# ifdef HAVE_RTAPI_MODULE_TIMER_STOP
_rtapi_module_timer_stop();
# endif
rtapi_data->timer_period = 0;
max_delay = DEFAULT_MAX_DELAY;
rtapi_data->timer_running = 0;
}
}
#endif /* MODULE */
#ifdef HAVE_RTAPI_TASK_DELETE_HOOK
retval = _rtapi_task_delete_hook(task,task_id);
#endif
if (task->state != DELETE_LOCKED) // we don't already hold mutex
rtapi_mutex_give(&(rtapi_data->mutex));
task->state = EMPTY;
task->magic = 0;
rtapi_print_msg(RTAPI_MSG_DBG, "rt_task_delete %d \"%s\"\n", task_id,
task->name );
return retval;
}
int _rtapi_exit(int module_id) {
int retval;
rtapi_mutex_get(&(rtapi_data->mutex));
retval = module_delete(module_id);
rtapi_mutex_give(&(rtapi_data->mutex));
return retval;
}
int rtapi_fifo_delete(int fifo_id, int module_id)
{
int retval;
rtapi_mutex_get(&(rtapi_data->mutex));
retval = fifo_delete(fifo_id, module_id);
rtapi_mutex_give(&(rtapi_data->mutex));
return retval;
}
void rtapi_autorelease_mutex(void *variable)
{
if (rtapi_data != NULL)
rtapi_mutex_give(&(rtapi_data->mutex));
else
// programming error
rtapi_print_msg(RTAPI_MSG_ERR,
"rtapi_autorelease_mutex: rtapi_data == NULL!\n");
}
int rtapi_shmem_delete(int shmem_id, int module_id)
{
int retval;
rtapi_mutex_get(&(rtapi_data->mutex));
retval = shmem_delete(shmem_id, module_id);
rtapi_mutex_give(&(rtapi_data->mutex));
return retval;
}
char *hal_comp_name(int comp_id)
{
hal_comp_t *comp;
char *result = NULL;
rtapi_mutex_get(&(hal_data->mutex));
comp = halpr_find_comp_by_id(comp_id);
if(comp) result = comp->name;
rtapi_mutex_give(&(hal_data->mutex));
return result;
}
/***********************************************************************
* Scope exit unlock helper *
* see hal_priv.h for usage hints *
************************************************************************/
void halpr_autorelease_mutex(void *variable)
{
if (hal_data != NULL)
rtapi_mutex_give(&(hal_data->mutex));
else
// programming error
hal_print_msg(RTAPI_MSG_ERR,
"HAL:%d BUG: halpr_autorelease_mutex called before hal_data inited\n",
rtapi_instance);
}
int _rtapi_shmem_delete_inst(int handle, int instance, int module_id) {
shmem_data *shmem;
int retval = 0;
if(handle < 1 || handle >= RTAPI_MAX_SHMEMS)
return -EINVAL;
rtapi_mutex_get(&(rtapi_data->mutex));
shmem = &shmem_array[handle];
/* validate shmem handle */
if (shmem->magic != SHMEM_MAGIC) {
rtapi_mutex_give(&(rtapi_data->mutex));
return -EINVAL;
}
shmem->count --;
if(shmem->count) {
rtapi_mutex_give(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_DBG,
"rtapi_shmem_delete: handle=%d module=%d key=0x%x: "
"%d remaining users\n",
handle, module_id, shmem->key, shmem->count);
return 0;
}
retval = shm_common_detach(shmem->size, shmem->mem);
if (retval < 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"RTAPI:%d ERROR: munmap(0x%8.8x) failed: %s\n",
instance, shmem->key, strerror(-retval));
}
// XXX: probably shmem->mem should be set to NULL here to avoid
// references to already unmapped segments (and find them early)
/* free the shmem structure */
shmem->magic = 0;
rtapi_mutex_give(&(rtapi_data->mutex));
return retval;
}
int _rtapi_init(const char *modname) {
int n, module_id = -ENOMEM;
module_data *module;
/* say hello */
rtapi_print_msg(RTAPI_MSG_DBG, "RTAPI: initing module %s\n", modname);
/* get the mutex */
rtapi_mutex_get(&(rtapi_data->mutex));
/* find empty spot in module array */
n = 1;
while ((n <= RTAPI_MAX_MODULES) && (module_array[n].state != NO_MODULE)) {
n++;
}
if (n > RTAPI_MAX_MODULES) {
/* no room */
rtapi_mutex_give(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_ERR, "RTAPI: ERROR: reached module limit %d\n",
n);
return -EMFILE;
}
/* we have space for the module */
module_id = n + MODULE_OFFSET;
module = &(module_array[n]);
/* update module data */
module->state = REALTIME;
if (modname != NULL) {
/* use name supplied by caller, truncating if needed */
rtapi_snprintf(module->name, RTAPI_NAME_LEN, "%s", modname);
} else {
/* make up a name */
rtapi_snprintf(module->name, RTAPI_NAME_LEN, "ULMOD%03d", module_id);
}
rtapi_data->ul_module_count++;
rtapi_print_msg(RTAPI_MSG_DBG, "RTAPI: module '%s' loaded, ID: %d\n",
module->name, module_id);
rtapi_mutex_give(&(rtapi_data->mutex));
return module_id;
}
void init_rtapi_data(rtapi_data_t * data)
{
int n, m;
/* has the block already been initialized? */
if (data->magic == RTAPI_MAGIC) {
/* yes, nothing to do */
return;
}
/* no, we need to init it, grab mutex unconditionally */
rtapi_mutex_try(&(data->mutex));
/* set magic number so nobody else init's the block */
data->magic = RTAPI_MAGIC;
/* set version code and flavor ID so other modules can check it */
data->serial = RTAPI_SERIAL;
data->thread_flavor_id = THREAD_FLAVOR_ID;
data->ring_mutex = 0;
/* and get busy */
data->rt_module_count = 0;
data->ul_module_count = 0;
data->task_count = 0;
data->shmem_count = 0;
data->timer_running = 0;
data->timer_period = 0;
/* init the arrays */
for (n = 0; n <= RTAPI_MAX_MODULES; n++) {
data->module_array[n].state = EMPTY;
data->module_array[n].name[0] = '\0';
}
for (n = 0; n <= RTAPI_MAX_TASKS; n++) {
data->task_array[n].state = EMPTY;
data->task_array[n].prio = 0;
data->task_array[n].owner = 0;
data->task_array[n].taskcode = NULL;
data->task_array[n].cpu = -1; // use default
}
for (n = 0; n <= RTAPI_MAX_SHMEMS; n++) {
data->shmem_array[n].key = 0;
data->shmem_array[n].rtusers = 0;
data->shmem_array[n].ulusers = 0;
data->shmem_array[n].size = 0;
for (m = 0; m < RTAPI_BITMAP_SIZE(RTAPI_MAX_SHMEMS +1); m++) {
data->shmem_array[n].bitmap[m] = 0;
}
}
/* done, release the mutex */
rtapi_mutex_give(&(data->mutex));
return;
}
int _rtapi_exit(int module_id) {
module_id -= MODULE_OFFSET;
if (module_id < 0 || module_id >= RTAPI_MAX_MODULES)
return -1;
/* Remove the module from the module_array. */
rtapi_mutex_get(&(rtapi_data->mutex));
module_array[module_id].state = NO_MODULE;
rtapi_print_msg(RTAPI_MSG_DBG,
"rtapi_exit: freed module slot %d, was %s\n",
module_id, module_array[module_id].name);
rtapi_mutex_give(&(rtapi_data->mutex));
return 0;
}
void vs_ring_write(msg_level_t level, const char *format, va_list ap)
{
int n;
rtapi_msg_t logmsg;
#if defined(RTAPI) && defined(BUILD_SYS_USER_DSO)
static pid_t rtapi_pid;
if (rtapi_pid == 0)
rtapi_pid = getpid();
#endif
if (global_data) {
// one-time initialisation
if (!rtapi_message_buffer.header) {
ringbuffer_init(&global_data->rtapi_messages, &rtapi_message_buffer);
}
logmsg.hdr.origin = MSG_ORIGIN;
#if defined(RTAPI) && defined(BUILD_SYS_KBUILD)
logmsg.hdr.pid = 0;
#endif
#if defined(RTAPI) && defined(BUILD_SYS_USER_DSO)
logmsg.hdr.pid = rtapi_pid;
#endif
#if defined(ULAPI)
logmsg.hdr.pid = getpid();
#endif
logmsg.hdr.level = level;
logmsg.hdr.encoding = MSG_ASCII;
strncpy(logmsg.hdr.tag, logtag, sizeof(logmsg.hdr.tag));
// do format outside critical section
n = vsnprintf(logmsg.buf, RTPRINTBUFFERLEN, format, ap);
if (rtapi_message_buffer.header->use_wmutex &&
rtapi_mutex_try(&rtapi_message_buffer.header->wmutex)) {
global_data->error_ring_locked++;
return;
}
// use copying writer to shorten criticial section
record_write(&rtapi_message_buffer, (void *) &logmsg,
sizeof(rtapi_msgheader_t) + n + 1); // trailing zero
if (rtapi_message_buffer.header->use_wmutex)
rtapi_mutex_give(&rtapi_message_buffer.header->wmutex);
}
}
// part of public API
void *hal_malloc(long int size)
{
void *retval;
if (hal_data == 0) {
HALERR("hal_malloc called before init");
return 0;
}
/* get the mutex */
rtapi_mutex_get(&(hal_data->mutex));
/* allocate memory */
retval = shmalloc_up(size);
/* release the mutex */
rtapi_mutex_give(&(hal_data->mutex));
/* check return value */
if (retval == 0) {
HALDBG("hal_malloc() can't allocate %ld bytes", size);
}
return retval;
}
/* release_HAL_mutex() unconditionally releases the hal_mutex
very useful after a program segfaults while holding the mutex
*/
static int release_HAL_mutex(void)
{
int comp_id, mem_id, retval;
void *mem;
hal_data_t *hal_data;
/* do RTAPI init */
comp_id = rtapi_init("hal_unlocker");
if (comp_id < 0) {
rtapi_print_msg(RTAPI_MSG_ERR, "ERROR: rtapi init failed\n");
return -EINVAL;
}
/* get HAL shared memory block from RTAPI */
mem_id = rtapi_shmem_new(HAL_KEY, comp_id, global_data->hal_size);
if (mem_id < 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"ERROR: could not open shared memory\n");
rtapi_exit(comp_id);
return -EINVAL;
}
/* get address of shared memory area */
retval = rtapi_shmem_getptr(mem_id, &mem);
if (retval < 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"ERROR: could not access shared memory\n");
rtapi_exit(comp_id);
return -EINVAL;
}
/* set up internal pointers to shared mem and data structure */
hal_data = (hal_data_t *) mem;
/* release mutex */
rtapi_mutex_give(&(hal_data->mutex));
/* release RTAPI resources */
rtapi_shmem_delete(mem_id, comp_id);
rtapi_exit(comp_id);
/* done */
return 0;
}
int rtapi_shmem_new(int key, int module_id, unsigned long int size)
{
int n;
int shmem_id;
shmem_data *shmem;
/* key must be non-zero, and also cannot match the key that RTAPI uses */
if ((key == 0) || (key == RTAPI_KEY)) {
rtapi_print_msg(RTAPI_MSG_ERR, "RTAPI: ERROR: bad shmem key: %d\n",
key);
return -EINVAL;
}
/* get the mutex */
rtapi_mutex_get(&(rtapi_data->mutex));
/* validate module_id */
if ((module_id < 1) || (module_id > RTAPI_MAX_MODULES)) {
rtapi_mutex_give(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_ERR, "RTAPI: ERROR: bad module ID: %d\n",
module_id);
return -EINVAL;
}
if (module_array[module_id].state != USERSPACE) {
rtapi_print_msg(RTAPI_MSG_ERR,
"RTAPI: ERROR: not a user space module ID: %d\n", module_id);
rtapi_mutex_give(&(rtapi_data->mutex));
return -EINVAL;
}
/* check if a block is already open for this key */
for (n = 1; n <= RTAPI_MAX_SHMEMS; n++) {
if (shmem_array[n].key == key) {
/* found a match */
shmem_id = n;
shmem = &(shmem_array[n]);
/* is it big enough? */
if (shmem->size < size) {
rtapi_mutex_give(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_ERR,
"RTAPI: ERROR: shmem size mismatch\n");
return -EINVAL;
}
/* is this module already using it? */
if (test_bit(module_id, shmem->bitmap)) {
rtapi_mutex_give(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_ERR,
"RTAPI: Warning: shmem already mapped\n");
return -EINVAL;
}
/* no, map it */
shmem_addr_array[shmem_id] = rtai_malloc(key, shmem->size);
// the check for -1 here is because rtai_malloc (in at least
// rtai 3.6.1, and probably others) has a bug where it
// sometimes returns -1 on error
if (shmem_addr_array[shmem_id] == NULL || shmem_addr_array[shmem_id] == (void*)-1) {
/* map failed */
rtapi_print_msg(RTAPI_MSG_ERR,
"RTAPI: ERROR: failed to map shmem\n");
rtapi_mutex_give(&(rtapi_data->mutex));
check_memlock_limit("failed to map shmem");
return -ENOMEM;
}
/* update usage data */
set_bit(module_id, shmem->bitmap);
shmem->ulusers++;
/* done */
rtapi_mutex_give(&(rtapi_data->mutex));
return shmem_id;
}
}
/* find empty spot in shmem array */
n = 1;
while ((n <= RTAPI_MAX_SHMEMS) && (shmem_array[n].key != 0)) {
n++;
}
if (n > RTAPI_MAX_SHMEMS) {
/* no room */
rtapi_mutex_give(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_ERR, "RTAPI: ERROR: reached shmem limit %d\n",
n);
return -EMFILE;
}
/* we have space for the block data */
shmem_id = n;
shmem = &(shmem_array[n]);
/* now get shared memory block from OS and save its address */
shmem_addr_array[shmem_id] = rtai_malloc(key, size);
// the check for -1 here is because rtai_malloc (in at least
// rtai 3.6.1, and probably others) has a bug where it
// sometimes returns -1 on error
if (shmem_addr_array[shmem_id] == NULL || shmem_addr_array[shmem_id] == (void*)-1) {
rtapi_mutex_give(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_ERR,
"RTAPI: ERROR: could not create shmem %d\n", n);
return -ENOMEM;
}
/* the block has been created, update data */
set_bit(module_id, shmem->bitmap);
shmem->key = key;
shmem->rtusers = 0;
shmem->ulusers = 1;
shmem->size = size;
rtapi_data->shmem_count++;
/* zero the first word of the shmem area */
*((long int *) (shmem_addr_array[shmem_id])) = 0;
/* done */
rtapi_mutex_give(&(rtapi_data->mutex));
return shmem_id;
}
static gboolean dialog_select_source(int chan_num)
{
scope_vert_t *vert;
scope_chan_t *chan;
dialog_generic_t dialog;
gchar *title, msg[BUFLEN];
int next, n, initial_page, row, initial_row, max_row;
gchar *tab_label_text[3], *name;
GtkWidget *hbox, *label, *notebk, *button;
GtkAdjustment *adj;
hal_pin_t *pin;
hal_sig_t *sig;
hal_param_t *param;
vert = &(ctrl_usr->vert);
chan = &(ctrl_usr->chan[chan_num - 1]);
title = _("Select Channel Source");
snprintf(msg, BUFLEN - 1, _("Select a pin, signal, or parameter\n"
"as the source for channel %d."), chan_num);
/* create dialog window, disable resizing */
dialog.retval = 0;
dialog.window = gtk_dialog_new();
dialog.app_data = &chan_num;
/* set initial height of window */
gtk_widget_set_usize(GTK_WIDGET(dialog.window), -2, 300);
/* allow user to grow but not shrink the window */
gtk_window_set_policy(GTK_WINDOW(dialog.window), FALSE, TRUE, FALSE);
/* window should appear in center of screen */
gtk_window_set_position(GTK_WINDOW(dialog.window), GTK_WIN_POS_CENTER);
/* set title */
gtk_window_set_title(GTK_WINDOW(dialog.window), title);
/* display message */
label = gtk_label_new(msg);
gtk_misc_set_padding(GTK_MISC(label), 15, 5);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog.window)->vbox), label, FALSE,
TRUE, 0);
/* a separator */
gtk_hseparator_new_in_box(GTK_DIALOG(dialog.window)->vbox, 0);
/* create a notebook to hold pin, signal, and parameter lists */
notebk = gtk_notebook_new();
/* add the notebook to the dialog */
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog.window)->vbox), notebk, TRUE,
TRUE, 0);
/* set overall notebook parameters */
gtk_notebook_set_homogeneous_tabs(GTK_NOTEBOOK(notebk), TRUE);
gtk_signal_connect(GTK_OBJECT(notebk), "switch-page", GTK_SIGNAL_FUNC(change_page), &dialog);
/* text for tab labels */
tab_label_text[0] = _("Pins");
tab_label_text[1] = _("Signals");
tab_label_text[2] = _("Parameters");
/* loop to create three identical tabs */
for (n = 0; n < 3; n++) {
/* Create a scrolled window to display the list */
vert->windows[n] = gtk_scrolled_window_new(NULL, NULL);
vert->adjs[n] = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(vert->windows[n]));
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(vert->windows[n]),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_widget_show(vert->windows[n]);
/* create a list to hold the data */
vert->lists[n] = gtk_clist_new(1);
/* set up a callback for when the user selects a line */
gtk_signal_connect(GTK_OBJECT(vert->lists[n]), "select_row",
GTK_SIGNAL_FUNC(selection_made), &dialog);
gtk_signal_connect(GTK_OBJECT(vert->lists[n]), "key-press-event",
GTK_SIGNAL_FUNC(search_for_entry), &dialog);
/* It isn't necessary to shadow the border, but it looks nice :) */
gtk_clist_set_shadow_type(GTK_CLIST(vert->lists[n]), GTK_SHADOW_OUT);
/* set list for single selection only */
gtk_clist_set_selection_mode(GTK_CLIST(vert->lists[n]),
GTK_SELECTION_BROWSE);
/* put the list into the scrolled window */
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW
(vert->windows[n]), vert->lists[n]);
/* another way to do it - not sure which is better
gtk_container_add(GTK_CONTAINER(vert->windows[n]), vert->lists[n]); */
gtk_widget_show(vert->lists[n]);
/* create a box for the tab label */
hbox = gtk_hbox_new(TRUE, 0);
/* create a label for the page */
gtk_label_new_in_box(tab_label_text[n], hbox, TRUE, TRUE, 0);
gtk_widget_show(hbox);
/* add page to the notebook */
gtk_notebook_append_page(GTK_NOTEBOOK(notebk), vert->windows[n], hbox);
/* set tab attributes */
gtk_notebook_set_tab_label_packing(GTK_NOTEBOOK(notebk), hbox,
TRUE, TRUE, GTK_PACK_START);
}
/* determine initial page: pin, signal, or parameter */
if (( chan->data_source_type >= 0 ) && ( chan->data_source_type <= 2 )) {
initial_page = chan->data_source_type;
gtk_notebook_set_page(GTK_NOTEBOOK(notebk), initial_page);
} else {
initial_page = -1;
gtk_notebook_set_page(GTK_NOTEBOOK(notebk), 0);
}
gtk_widget_show(notebk);
/* populate the pin, signal, and parameter lists */
gtk_clist_clear(GTK_CLIST(vert->lists[0]));
gtk_clist_clear(GTK_CLIST(vert->lists[1]));
gtk_clist_clear(GTK_CLIST(vert->lists[2]));
rtapi_mutex_get(&(hal_data->mutex));
next = hal_data->pin_list_ptr;
initial_row = -1;
max_row = -1;
while (next != 0) {
pin = SHMPTR(next);
name = pin->name;
row = gtk_clist_append(GTK_CLIST(vert->lists[0]), &name);
if ( initial_page == 0 ) {
if ( strcmp(name, chan->name) == 0 ) {
initial_row = row;
}
max_row = row;
}
next = pin->next_ptr;
}
next = hal_data->sig_list_ptr;
while (next != 0) {
sig = SHMPTR(next);
name = sig->name;
row = gtk_clist_append(GTK_CLIST(vert->lists[1]), &name);
if ( initial_page == 1 ) {
if ( strcmp(name, chan->name) == 0 ) {
initial_row = row;
}
max_row = row;
}
next = sig->next_ptr;
}
next = hal_data->param_list_ptr;
while (next != 0) {
param = SHMPTR(next);
name = param->name;
row = gtk_clist_append(GTK_CLIST(vert->lists[2]), &name);
if ( initial_page == 2 ) {
if ( strcmp(name, chan->name) == 0 ) {
initial_row = row;
}
max_row = row;
}
next = param->next_ptr;
}
rtapi_mutex_give(&(hal_data->mutex));
if ( initial_row >= 0 ) {
/* highlight the currently selected name */
gtk_clist_select_row(GTK_CLIST(vert->lists[initial_page]), initial_row, -1);
/* set scrolling window to show the highlighted name */
/* FIXME - I can't seem to get this to work */
adj = vert->adjs[initial_page];
adj->value = adj->lower + (adj->upper - adj->lower)*((double)(initial_row)/(double)(max_row+1));
gtk_adjustment_value_changed(vert->adjs[initial_page]);
}
/* set up a callback function when the window is destroyed */
gtk_signal_connect(GTK_OBJECT(dialog.window), "destroy",
GTK_SIGNAL_FUNC(dialog_generic_destroyed), &dialog);
/* make Cancel button */
button = gtk_button_new_with_label(_("Cancel"));
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog.window)->action_area),
button, TRUE, TRUE, 4);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(dialog_generic_button2), &dialog);
/* make window transient and modal */
gtk_window_set_transient_for(GTK_WINDOW(dialog.window),
GTK_WINDOW(ctrl_usr->main_win));
gtk_window_set_modal(GTK_WINDOW(dialog.window), TRUE);
gtk_widget_show_all(dialog.window);
gtk_main();
/* we get here when the user makes a selection, hits Cancel, or closes
the window */
vert->lists[0] = NULL;
vert->lists[1] = NULL;
vert->lists[2] = NULL;
if ((dialog.retval == 0) || (dialog.retval == 2)) {
/* user either closed dialog, or hit cancel */
return FALSE;
}
/* user made a selection */
channel_changed();
return TRUE;
}
int _rtapi_shmem_new_inst(int userkey, int instance, int module_id, unsigned long int size) {
int n, retval;
int shmem_id;
shmem_data *shmem;
struct shm_status sm;
int key = OS_KEY(userkey, instance);
/* key must be non-zero, and also cannot match the key that RTAPI uses */
if ((key == 0) || (key == OS_KEY(RTAPI_KEY, instance))) {
rtapi_print_msg(RTAPI_MSG_ERR, "RTAPI: ERROR: bad shmem key: %d\n",
key);
return -EINVAL;
}
/* get the mutex */
rtapi_mutex_get(&(rtapi_data->mutex));
/* validate module_id */
if ((module_id < 1) || (module_id > RTAPI_MAX_MODULES)) {
rtapi_mutex_give(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_ERR, "RTAPI: ERROR: bad module ID: %d\n",
module_id);
return -EINVAL;
}
if (module_array[module_id].state != MODULE_STATE) {
rtapi_print_msg(RTAPI_MSG_ERR,
"RTAPI: ERROR: not a " OUR_API " module ID: %d\n",
module_id);
rtapi_mutex_give(&(rtapi_data->mutex));
return -EINVAL;
}
/* check if a block is already open for this key */
for (n = 1; n <= RTAPI_MAX_SHMEMS; n++) {
if (shmem_array[n].key == key) {
/* found a match */
shmem_id = n;
shmem = &(shmem_array[n]);
/* is it big enough? */
if (shmem->size < size) {
rtapi_mutex_give(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_ERR,
"RTAPI: ERROR: shmem size mismatch\n");
return -EINVAL;
}
/* is this module already using it? */
if (rtapi_test_bit(module_id, shmem->bitmap)) {
rtapi_mutex_give(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_WARN,
"RTAPI: Warning: shmem already mapped\n");
return -EEXIST;
}
/* yes, has it been mapped into kernel space? */
#ifdef RTAPI
if (shmem->rtusers == 0) {
#endif
/* no, map it and save the address */
sm.key = key;
sm.size = size;
sm.flags = 0;
#ifdef ULAPI
sm.driver_fd = shmdrv_driver_fd();
#endif
retval = shmdrv_attach(&sm, &shmem_addr_array[shmem_id]);
if (retval < 0) {
rtapi_mutex_give(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_ERR,
"shmdrv attached failed key=0x%x size=%ld\n", key, size);
return retval;
}
if (shmem_addr_array[shmem_id] == NULL) {
rtapi_print_msg(RTAPI_MSG_ERR,
"RTAPI: ERROR: failed to map shmem\n");
rtapi_mutex_give(&(rtapi_data->mutex));
#ifdef ULAPI
check_memlock_limit("failed to map shmem");
#endif
return -ENOMEM;
}
#ifdef RTAPI
}
#endif
/* update usage data */
rtapi_set_bit(module_id, shmem->bitmap);
#ifdef ULAPI
shmem->ulusers++;
#else /* RTAPI */
shmem->rtusers++;
#endif /* RTAPI */
/* announce another user for this shmem */
rtapi_print_msg(RTAPI_MSG_DBG,
"RTAPI: shmem %02d opened by module %02d\n",
shmem_id, module_id);
/* done */
rtapi_mutex_give(&(rtapi_data->mutex));
return shmem_id;
}
}
/* find empty spot in shmem array */
n = 1;
while ((n <= RTAPI_MAX_SHMEMS) && (shmem_array[n].key != 0)) {
rtapi_print_msg(RTAPI_MSG_DBG, OUR_API ": shmem %d occupuied \n",n);
n++;
}
if (n > RTAPI_MAX_SHMEMS) {
/* no room */
rtapi_mutex_give(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_ERR, "RTAPI: ERROR: reached shmem limit %d\n",
n);
return -EMFILE;
}
/* we have space for the block data */
rtapi_print_msg(RTAPI_MSG_DBG, OUR_API ": using new shmem %d \n",n);
shmem_id = n;
shmem = &(shmem_array[n]);
/* get shared memory block from OS and save its address */
sm.key = key;
sm.size = size;
sm.flags = 0;
#ifdef ULAPI
sm.driver_fd = shmdrv_driver_fd();
#endif
retval = shmdrv_create(&sm);
if (retval < 0) {
rtapi_mutex_give(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_ERR,"shmdrv create failed key=0x%x size=%ld\n", key, size);
return retval;
}
retval = shmdrv_attach(&sm, &shmem_addr_array[shmem_id]);
if (retval < 0) {
rtapi_mutex_give(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_ERR,"shmdrv attached failed key=0x%x size=%ld\n", key, size);
return retval;
}
if (shmem_addr_array[shmem_id] == NULL) {
rtapi_mutex_give(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_ERR,
"RTAPI: ERROR: could not create shmem %d\n", n);
return -ENOMEM;
}
/* the block has been created, update data */
rtapi_set_bit(module_id, shmem->bitmap);
shmem->key = key;
#ifdef RTAPI
shmem->rtusers = 1;
shmem->ulusers = 0;
#else /* ULAPI */
shmem->rtusers = 0;
shmem->ulusers = 1;
#endif /* ULAPI */
shmem->size = size;
shmem->magic = SHMEM_MAGIC;
shmem->instance = instance;
rtapi_data->shmem_count++;
/* zero the first word of the shmem area */
*((long int *) (shmem_addr_array[shmem_id])) = 0;
/* announce the birth of a brand new baby shmem */
rtapi_print_msg(RTAPI_MSG_DBG,
"RTAPI: shmem %02d created by module %02d, key: %d, size: %lu\n",
shmem_id, module_id, key, size);
/* and return the ID to the proud parent */
rtapi_mutex_give(&(rtapi_data->mutex));
return shmem_id;
}
int _rtapi_task_new(const rtapi_task_args_t *args) {
int task_id;
int __attribute__((__unused__)) retval = 0;
task_data *task;
/* get the mutex */
rtapi_mutex_get(&(rtapi_data->mutex));
#ifdef MODULE
/* validate owner */
if ((args->owner < 1) || (args->owner > RTAPI_MAX_MODULES)) {
rtapi_mutex_give(&(rtapi_data->mutex));
return -EINVAL;
}
if (module_array[args->owner].state != REALTIME) {
rtapi_mutex_give(&(rtapi_data->mutex));
return -EINVAL;
}
if ((args->flags & (TF_NONRT|TF_NOWAIT)) != 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"task '%s' : nowait/posix flags not supported with kthreads\n",
args->name);
rtapi_mutex_give(&(rtapi_data->mutex));
return -EINVAL;
}
#endif
/* find an empty entry in the task array */
task_id = 1; // tasks start at one!
// go through task_array until an empty task slot is found
while ((task_id < RTAPI_MAX_TASKS) &&
(task_array[task_id].magic == TASK_MAGIC))
task_id++;
// if task_array is full, release lock and return error
if (task_id == RTAPI_MAX_TASKS) {
rtapi_mutex_give(&(rtapi_data->mutex));
return -ENOMEM;
}
task = &(task_array[task_id]);
// if requested priority is invalid, release lock and return error
if (PRIO_LT(args->prio,_rtapi_prio_lowest()) ||
PRIO_GT(args->prio,_rtapi_prio_highest())) {
rtapi_print_msg(RTAPI_MSG_ERR,
"New task %d '%s:%d': invalid priority %d "
"(highest=%d lowest=%d)\n",
task_id, args->name, rtapi_instance, args->prio,
_rtapi_prio_highest(),
_rtapi_prio_lowest());
rtapi_mutex_give(&(rtapi_data->mutex));
return -EINVAL;
}
if ((args->flags & (TF_NOWAIT|TF_NONRT)) == TF_NOWAIT) {
rtapi_print_msg(RTAPI_MSG_ERR,"task '%s' : nowait flag invalid for RT thread\n",
args->name);
rtapi_mutex_give(&(rtapi_data->mutex));
return -EINVAL;
}
// task slot found; reserve it and release lock
rtapi_print_msg(RTAPI_MSG_DBG,
"Creating new task %d '%s:%d': "
"req prio %d (highest=%d lowest=%d) stack=%lu fp=%d flags=%d\n",
task_id, args->name, rtapi_instance, args->prio,
_rtapi_prio_highest(),
_rtapi_prio_lowest(),
args->stacksize, args->uses_fp, args->flags);
task->magic = TASK_MAGIC;
/* fill out task structure */
task->owner = args->owner;
task->arg = args->arg;
task->stacksize = (args->stacksize < MIN_STACKSIZE) ? MIN_STACKSIZE : args->stacksize;
task->taskcode = args->taskcode;
task->prio = args->prio;
task->flags = args->flags;
task->uses_fp = args->uses_fp;
task->cpu = args->cpu_id > -1 ? args->cpu_id : rtapi_data->rt_cpu;
rtapi_print_msg(RTAPI_MSG_DBG, "Task CPU: %d\n", task->cpu);
rtapi_snprintf(task->name, sizeof(task->name),
"%s:%d", args->name, rtapi_instance);
task->name[sizeof(task->name) - 1] = '\0';
#ifdef MODULE
/* get space for the OS's task data - this is around 900 bytes, */
/* so we don't want to statically allocate it for unused tasks. */
ostask_array[task_id] = kmalloc(sizeof(RT_TASK), GFP_USER);
if (ostask_array[task_id] == NULL) {
rtapi_mutex_give(&(rtapi_data->mutex));
return -ENOMEM;
}
#ifdef HAVE_RTAPI_TASK_NEW_HOOK
/* kernel threads: rtapi_task_new_hook() should call OS to
initialize the task - use predetermined or explicitly assigned
CPU */
retval = _rtapi_task_new_hook(task, task_id);
if (retval) {
rtapi_print_msg(RTAPI_MSG_ERR,
"rt_task_create failed, rc = %d\n", retval );
/* couldn't create task, free task data memory */
kfree(ostask_array[task_id]);
rtapi_mutex_give(&(rtapi_data->mutex));
if (retval == ENOMEM) {
/* not enough space for stack */
return -ENOMEM;
}
/* unknown error */
return -EINVAL;
}
#endif
/* the task has been created, update data */
task->state = PAUSED;
retval = task_id;
#else /* userland thread */
/* userland threads: rtapi_task_new_hook() should perform any
thread system-specific tasks, and return task_id or an error
code back to the caller (how do we know the diff between an
error and a task_id???). */
task->state = USERLAND; // userland threads don't track this
# ifdef HAVE_RTAPI_TASK_NEW_HOOK
retval = _rtapi_task_new_hook(task,task_id);
# else
retval = task_id;
# endif
#endif /* userland thread */
rtapi_data->task_count++;
rtapi_mutex_give(&(rtapi_data->mutex));
/* announce the birth of a brand new baby task */
rtapi_print_msg(RTAPI_MSG_DBG,
"RTAPI: task %02d installed by module %02d, priority %d, code: %p\n",
task_id, task->owner, task->prio, args->taskcode);
return task_id;
}
int _rtapi_shmem_delete_inst(int shmem_id, int instance, int module_id) {
shmem_data *shmem;
int manage_lock, retval;
#ifdef RTAPI
struct shm_status sm;
#endif
/* validate shmem ID */
if ((shmem_id < 1) || (shmem_id > RTAPI_MAX_SHMEMS)) {
return -EINVAL;
}
/* point to the shmem's data */
shmem = &(shmem_array[shmem_id]);
/* is the block valid? */
if (shmem->key == 0) {
return -EINVAL;
}
/* validate module_id */
if ((module_id < 1) || (module_id > RTAPI_MAX_MODULES)) {
return -EINVAL;
}
if (module_array[module_id].state != MODULE_STATE) {
return -EINVAL;
}
/* is this module using the block? */
if (rtapi_test_bit(module_id, shmem->bitmap) == 0) {
return -EINVAL;
}
/* check if we need to manage the mutex */
manage_lock = (shmem->magic != SHMEM_MAGIC_DEL_LOCKED);
/* if no magic delete lock held is set, get the mutex */
if (manage_lock) rtapi_mutex_get(&(rtapi_data->mutex));
/* OK, we're no longer using it */
rtapi_clear_bit(module_id, shmem->bitmap);
#ifdef ULAPI
shmem->ulusers--;
if ((shmem->ulusers == 0) && (shmem->rtusers == 0)) {
// shmdrv can detach unused shared memory from userland too
// this will munmap() the segment causing a drop in uattach refcount
// and eventual free by garbage collect in shmdrv
retval = shm_common_detach(shmem->size, shmem_addr_array[shmem_id]);
if (retval) {
rtapi_print_msg(RTAPI_MSG_ERR,
"ULAPI:%d ERROR: shm_common_detach(%02d) failed: %s\n",
rtapi_instance, shmem_id, strerror(-retval));
}
}
/* unmap the block */
shmem_addr_array[shmem_id] = NULL;
#else /* RTAPI */
shmem->rtusers--;
#endif /* RTAPI */
/* is somebody else still using the block? */
if ((shmem->ulusers > 0) || (shmem->rtusers > 0)) {
/* yes, we're done for now */
rtapi_print_msg(RTAPI_MSG_DBG,
"RTAPI: shmem %02d closed by module %02d\n", shmem_id, module_id);
if (manage_lock) rtapi_mutex_give(&(rtapi_data->mutex));
return 0;
}
#ifdef RTAPI
/* no other realtime users, free the shared memory from kernel space */
shmem_addr_array[shmem_id] = NULL;
shmem->rtusers = 0;
/* are any user processes using the block? */
if (shmem->ulusers > 0) {
/* yes, we're done for now */
rtapi_print_msg(RTAPI_MSG_DBG,
"RTAPI: shmem %02d unmapped by module %02d\n", shmem_id,
module_id);
if (manage_lock) rtapi_mutex_give(&(rtapi_data->mutex));
return 0;
}
/* no other users at all, this ID is now free */
sm.key = shmem->key;
sm.size = shmem->size;
sm.flags = 0;
if ((retval = shmdrv_detach(&sm)) < 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"RTAPI:%d ERROR: shmdrv_detach(%x,%d) fail: %d\n",
rtapi_instance, sm.key, sm.size, retval);
}
#endif /* RTAPI */
/* update the data array and usage count */
shmem->key = 0;
shmem->size = 0;
rtapi_data->shmem_count--;
/* release the lock if needed, print a debug message and return */
if (manage_lock) rtapi_mutex_give(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_DBG, "RTAPI: shmem %02d freed by module %02d\n",
shmem_id, module_id);
return 0;
}
void init_global_data(global_data_t * data, int flavor,
int instance_id, int hal_size,
int rt_level, int user_level,
const char *name, int stack_size)
{
// force-lock - we're first, so thats a bit theoretical
rtapi_mutex_try(&(data->mutex));
// touch all memory exposed to RT
memset(data, 0, sizeof(global_data_t));
// lock the global data segment
if (flavor != RTAPI_POSIX_ID) {
if (mlock(data, sizeof(global_data_t))) {
syslog_async(LOG_ERR, "MSGD:%d mlock(global) failed: %d '%s'\n",
instance_id, errno,strerror(errno));
}
}
// report progress
data->magic = GLOBAL_INITIALIZING;
/* set version code so other modules can check it */
data->layout_version = GLOBAL_LAYOUT_VERSION;
data->instance_id = instance_id;
if ((name == NULL) || (strlen(name) == 0)) {
snprintf(data->instance_name, sizeof(data->instance_name),
"inst%d",rtapi_instance);
} else {
strncpy(data->instance_name,name, sizeof(data->instance_name));
}
// separate message levels for RT and userland
data->rt_msg_level = rt_level;
data->user_msg_level = user_level;
// next value returned by rtapi_init (userland threads)
// those dont use fixed sized arrays
// start at 1 because the meaning of zero is special
data->next_module_id = 1;
// tell the others what we determined as the proper flavor
data->rtapi_thread_flavor = flavor;
// HAL segment size
data->hal_size = hal_size;
// stack size passed to rtapi_task_new() in hal_create_thread()
data->hal_thread_stack_size = stack_size;
// init the error ring
ringheader_init(&data->rtapi_messages, 0, SIZE_ALIGN(MESSAGE_RING_SIZE), 0);
memset(&data->rtapi_messages.buf[0], 0, SIZE_ALIGN(MESSAGE_RING_SIZE));
// attach to the message ringbuffer
ringbuffer_init(&data->rtapi_messages, &rtapi_msg_buffer);
rtapi_msg_buffer.header->refcount = 1; // rtapi not yet attached
rtapi_msg_buffer.header->reader = getpid();
data->rtapi_messages.use_wmutex = 1; // locking hint
// demon pids
data->rtapi_app_pid = -1; // not yet started
data->rtapi_msgd_pid = 0;
/* done, release the mutex */
rtapi_mutex_give(&(data->mutex));
return;
}
int _rtapi_shmem_new_inst(int userkey, int instance, int module_id, unsigned long int size) {
shmem_data *shmem;
int i, ret, actual_size;
int is_new = 0;
int key = OS_KEY(userkey, instance);
static int page_size;
if (!page_size)
page_size = sysconf(_SC_PAGESIZE);
rtapi_mutex_get(&(rtapi_data->mutex));
for (i = 1 ; i < RTAPI_MAX_SHMEMS; i++) {
if (shmem_array[i].magic == SHMEM_MAGIC && shmem_array[i].key == key) {
shmem_array[i].count ++;
rtapi_mutex_give(&(rtapi_data->mutex));
return i;
}
if (shmem_array[i].magic != SHMEM_MAGIC)
break;
}
if (i == RTAPI_MAX_SHMEMS) {
rtapi_mutex_give(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_ERR,
"rtapi_shmem_new failed due to RTAPI_MAX_SHMEMS\n");
return -ENOMEM;
}
shmem = &shmem_array[i];
// redefine size == 0 to mean 'attach only, dont create'
actual_size = size;
ret = shm_common_new(key, &actual_size, instance, &shmem->mem, size > 0);
if (ret > 0)
is_new = 1;
if (ret < 0) {
rtapi_mutex_give(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_ERR,
"shm_common_new:%d failed key=0x%x size=%ld\n",
instance, key, size);
return ret;
}
// a non-zero size was given but it didn match what we found:
if (size && (actual_size != size)) {
rtapi_print_msg(RTAPI_MSG_ERR,
"rtapi_shmem_new:%d 0x8.8%x: requested size %ld and actual size %d dont match\n",
instance, key, size, actual_size);
}
/* Touch each page by either zeroing the whole mem (if it's a new
SHM region), or by reading from it. */
if (is_new) {
memset(shmem->mem, 0, size);
} else {
unsigned int i;
for (i = 0; i < size; i += page_size) {
unsigned int x = *(volatile unsigned int *)
((unsigned char *)shmem->mem + i);
/* Use rand_r to clobber the read so GCC won't optimize it
out. */
rand_r(&x);
}
}
/* label as a valid shmem structure */
shmem->magic = SHMEM_MAGIC;
/* fill in the other fields */
shmem->size = actual_size;
shmem->key = key;
shmem->count = 1;
shmem->instance = instance;
rtapi_mutex_give(&(rtapi_data->mutex));
/* return handle to the caller */
return i;
}
int rtapi_fifo_new(int key, int module_id, unsigned long int size, char mode)
{
enum { DEVSTR_LEN = 256 };
char devstr[DEVSTR_LEN];
int n, flags;
int fifo_id;
fifo_data *fifo;
/* key must be non-zero */
if (key == 0) {
return -EINVAL;
}
/* mode must be "R" or "W" */
if ((mode != 'R') && (mode != 'W')) {
return -EINVAL;
}
/* determine mode for fifo */
if (mode == 'R') {
flags = O_RDONLY;
} else { /* mode == 'W' */
flags = O_WRONLY;
}
/* get the mutex */
rtapi_mutex_get(&(rtapi_data->mutex));
/* validate module_id */
if ((module_id < 1) || (module_id > RTAPI_MAX_MODULES)) {
rtapi_mutex_give(&(rtapi_data->mutex));
return -EINVAL;
}
if (module_array[module_id].state != USERSPACE) {
rtapi_mutex_give(&(rtapi_data->mutex));
return -EINVAL;
}
/* check if a fifo already exists for this key */
for (n = 1; n <= RTAPI_MAX_FIFOS; n++) {
if ((fifo_array[n].state != UNUSED) && (fifo_array[n].key == key)) {
/* found a match */
fifo_id = n;
fifo = &(fifo_array[n]);
/* is the desired mode available */
if (mode == 'R') {
if (fifo->state & HAS_READER) {
rtapi_mutex_give(&(rtapi_data->mutex));
return -EBUSY;
}
/* determine system name for fifo */
sprintf(devstr, "/dev/rtf%d", fifo_id);
/* open the fifo */
fifo_fd_array[fifo_id] = open(devstr, flags);
if (fifo_fd_array[fifo_id] < 0) {
/* open failed */
rtapi_mutex_give(&(rtapi_data->mutex));
return -ENOENT;
}
/* fifo opened, update status */
fifo->state |= HAS_READER;
fifo->reader = module_id;
rtapi_mutex_give(&(rtapi_data->mutex));
return fifo_id;
} else { /* mode == 'W' */
if (fifo->state & HAS_WRITER) {
rtapi_mutex_give(&(rtapi_data->mutex));
return -EBUSY;
}
/* determine system name for fifo */
sprintf(devstr, "/dev/rtf%d", fifo_id);
/* open the fifo */
fifo_fd_array[fifo_id] = open(devstr, flags);
if (fifo_fd_array[fifo_id] < 0) {
/* open failed */
rtapi_mutex_give(&(rtapi_data->mutex));
return -ENOENT;
}
/* fifo opened, update status */
fifo->state |= HAS_WRITER;
fifo->writer = module_id;
rtapi_mutex_give(&(rtapi_data->mutex));
return fifo_id;
}
}
}
/* find empty spot in fifo array */
n = 1;
while ((n <= RTAPI_MAX_FIFOS) && (fifo_array[n].state != UNUSED)) {
n++;
}
if (n > RTAPI_MAX_FIFOS) {
/* no room */
rtapi_mutex_give(&(rtapi_data->mutex));
return -EMFILE;
}
/* we have a free ID for the fifo */
fifo_id = n;
fifo = &(fifo_array[n]);
/* determine system name for fifo */
sprintf(devstr, "/dev/rtf%d", fifo_id);
/* open the fifo */
fifo_fd_array[fifo_id] = open(devstr, flags);
if (fifo_fd_array[fifo_id] < 0) {
/* open failed */
rtapi_mutex_give(&(rtapi_data->mutex));
return -ENOENT;
}
/* the fifo has been created, update data */
if (mode == 'R') {
fifo->state = HAS_READER;
fifo->reader = module_id;
} else { /* mode == 'W' */
fifo->state = HAS_WRITER;
fifo->writer = module_id;
}
fifo->key = key;
fifo->size = size;
rtapi_data->fifo_count++;
/* done */
rtapi_mutex_give(&(rtapi_data->mutex));
return fifo_id;
}
static int hal_export_xfunctfv(const hal_export_xfunct_args_t *xf, const char *fmt, va_list ap)
{
int *prev, next, cmp, sz;
hal_funct_t *nf, *fptr;
char name[HAL_NAME_LEN + 1];
CHECK_HALDATA();
CHECK_LOCK(HAL_LOCK_LOAD);
sz = rtapi_vsnprintf(name, sizeof(name), fmt, ap);
if(sz == -1 || sz > HAL_NAME_LEN) {
HALERR("length %d invalid for name starting '%s'", sz, name);
return -ENOMEM;
}
HALDBG("exporting function '%s' type %d", name, xf->type);
{
hal_comp_t *comp __attribute__((cleanup(halpr_autorelease_mutex)));
/* get mutex before accessing shared data */
rtapi_mutex_get(&(hal_data->mutex));
comp = halpr_find_owning_comp(xf->owner_id);
if (comp == 0) {
/* bad comp_id */
HALERR("funct '%s': owning component %d not found",
name, xf->owner_id);
return -EINVAL;
}
if (comp->type == TYPE_USER) {
/* not a realtime component */
HALERR("funct '%s': component %s/%d is not realtime (%d)",
name, comp->name, comp->comp_id, comp->type);
return -EINVAL;
}
bool legacy = (halpr_find_inst_by_id(xf->owner_id) == NULL);
// instances may export functs post hal_ready
if (legacy && (comp->state > COMP_INITIALIZING)) {
HALERR("funct '%s': called after hal_ready", name);
return -EINVAL;
}
/* allocate a new function structure */
nf = alloc_funct_struct();
if (nf == 0)
NOMEM("function '%s'", name);
/* initialize the structure */
nf->uses_fp = xf->uses_fp;
nf->owner_id = xf->owner_id;
nf->reentrant = xf->reentrant;
nf->users = 0;
nf->handle = rtapi_next_handle();
nf->arg = xf->arg;
nf->type = xf->type;
nf->funct.l = xf->funct.l; // a bit of a cheat really
rtapi_snprintf(nf->name, sizeof(nf->name), "%s", name);
/* search list for 'name' and insert new structure */
prev = &(hal_data->funct_list_ptr);
next = *prev;
while (1) {
if (next == 0) {
/* reached end of list, insert here */
nf->next_ptr = next;
*prev = SHMOFF(nf);
/* break out of loop and init the new function */
break;
}
fptr = SHMPTR(next);
cmp = strcmp(fptr->name, nf->name);
if (cmp > 0) {
/* found the right place for it, insert here */
nf->next_ptr = next;
*prev = SHMOFF(nf);
/* break out of loop and init the new function */
break;
}
if (cmp == 0) {
/* name already in list, can't insert */
free_funct_struct(nf);
HALERR("duplicate function '%s'", name);
return -EINVAL;
}
/* didn't find it yet, look at next one */
prev = &(fptr->next_ptr);
next = *prev;
}
// at this point we have a new function and can
// yield the mutex by scope exit
}
/* init time logging variables */
nf->runtime = 0;
nf->maxtime = 0;
nf->maxtime_increased = 0;
/* at this point we have a new function and can yield the mutex */
rtapi_mutex_give(&(hal_data->mutex));
switch (xf->type) {
case FS_LEGACY_THREADFUNC:
case FS_XTHREADFUNC:
/* create a pin with the function's runtime in it */
if (hal_pin_s32_newf(HAL_OUT, &(nf->runtime), xf->owner_id, "%s.time",name)) {
HALERR("failed to create pin '%s.time'", name);
return -EINVAL;
}
*(nf->runtime) = 0;
/* note that failure to successfully create the following params
does not cause the "export_funct()" call to fail - they are
for debugging and testing use only */
/* create a parameter with the function's maximum runtime in it */
nf->maxtime = 0;
hal_param_s32_newf(HAL_RW, &(nf->maxtime), xf->owner_id, "%s.tmax", name);
/* create a parameter with the function's maximum runtime in it */
nf->maxtime_increased = 0;
hal_param_bit_newf(HAL_RO, &(nf->maxtime_increased), xf->owner_id,
"%s.tmax-inc", name);
break;
case FS_USERLAND: // no timing pins/params
;
}
return 0;
}
void cleanup_module(void) {
int n;
struct shm_status sm;
int retval;
if (rtapi_data == NULL) {
/* never got inited, nothing to do */
return;
}
#ifdef HAVE_RTAPI_MODULE_EXIT_HOOK
_rtapi_module_exit_hook();
#endif
/* grab the mutex */
rtapi_mutex_get(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_INFO, "RTAPI:%d exit\n", rtapi_instance);
/* clean up leftover modules (start at 1, we don't use ID 0 */
for (n = 1; n <= RTAPI_MAX_MODULES; n++) {
if (module_array[n].state == REALTIME) {
rtapi_print_msg(RTAPI_MSG_WARN,
"RTAPI: WARNING: module '%s' (ID: %02d) did not "
"call rtapi_exit()\n",
module_array[n].name, n);
module_delete(n);
}
}
/* cleaning up modules should clean up everything, if not there has
probably been an unrecoverable internal error.... */
for (n = 1; n <= RTAPI_MAX_SHMEMS; n++) {
if (shmem_array[n].rtusers > 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"RTAPI: ERROR: shared memory block %02d not deleted\n", n);
}
}
for (n = 1; n <= RTAPI_MAX_TASKS; n++) {
if (task_array[n].state != EMPTY) {
rtapi_print_msg(RTAPI_MSG_ERR,
"RTAPI: ERROR: task %02d not deleted\n", n);
/* probably un-recoverable, but try anyway */
_rtapi_task_pause(n);
/* rtapi_task_delete should not grab mutex */
task_array[n].state = DELETE_LOCKED;
_rtapi_task_delete(n);
}
}
if (rtapi_data->timer_running != 0) {
#ifdef HAVE_RTAPI_MODULE_TIMER_STOP
_rtapi_module_timer_stop();
#endif
rtapi_data->timer_period = 0;
timer_counts = 0;
rtapi_data->timer_running = 0;
max_delay = DEFAULT_MAX_DELAY;
}
rtapi_mutex_give(&(rtapi_data->mutex));
#ifdef CONFIG_PROC_FS
proc_clean();
#endif
sm.key = OS_KEY(RTAPI_KEY, rtapi_instance);
sm.size = sizeof(rtapi_data_t);
sm.flags = 0;
if ((retval = shmdrv_detach(&sm)) < 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"RTAPI:%d ERROR: detach rtapi returns %d\n",
rtapi_instance, retval);
}
rtapi_data = NULL;
global_data->rtapi_messages.refcount -= 1; // detach rtapi end
sm.key = OS_KEY(GLOBAL_KEY, rtapi_instance);
sm.size = sizeof(global_data_t);
sm.flags = 0;
if ((retval = shmdrv_detach(&sm)) < 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"RTAPI:%d ERROR: detach global returns %d\n",
rtapi_instance, retval);
}
global_data = NULL;
rtapi_print_msg(RTAPI_MSG_INFO, "RTAPI:%d Exit complete\n",
rtapi_instance);
return;
}
int _rtapi_init(const char *modname) {
int n, module_id;
module_data *module;
struct shm_status sm;
int retval;
/* say hello */
rtapi_print_msg(RTAPI_MSG_DBG, "ULAPI:%d initing module %s\n",
rtapi_instance, modname);
errno = 0;
// if not done yet, attach global and rtapi_data segments now
if (global_data == NULL) {
sm.key = OS_KEY(GLOBAL_KEY, rtapi_instance);
sm.size = sizeof(global_data_t);
sm.flags = 0;
if ((retval = shmdrv_attach(&sm, (void **)&global_data)) < 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"ULAPI:%d ERROR: can attach global segment: %d\n",
rtapi_instance, retval);
return -EINVAL;
}
sm.key = OS_KEY(RTAPI_KEY, rtapi_instance);
sm.size = sizeof(rtapi_data_t);
sm.flags = 0;
if ((retval = shmdrv_attach(&sm, (void **)&rtapi_data)) < 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"ULAPI:%d ERROR: cant attach rtapi segment: %d\n",
rtapi_instance, retval);
return -EINVAL;
}
}
// I consider this very dubious - there is no reason for ULAPI to start without
// rtapi_data already being inited: -mah
// init_rtapi_data(rtapi_data);
/* check flavor and serial codes */
if (rtapi_data->thread_flavor_id != THREAD_FLAVOR_ID) {
/* mismatch - release master shared memory block */
rtapi_print_msg(RTAPI_MSG_ERR,
"ULAPI:%d ERROR: flavor mismatch %d vs %d\n",
rtapi_instance,
rtapi_data->thread_flavor_id, THREAD_FLAVOR_ID);
return -EINVAL;
}
if (rtapi_data->serial != RTAPI_SERIAL) {
/* mismatch - release master shared memory block */
rtapi_print_msg(RTAPI_MSG_ERR,
"ULAPI:%d ERROR: serial mismatch %d vs %d\n",
rtapi_instance, rtapi_data->serial, RTAPI_SERIAL);
return -EINVAL;
}
/* set up local pointers to global data */
module_array = rtapi_data->module_array;
task_array = rtapi_data->task_array;
shmem_array = rtapi_data->shmem_array;
/* perform local init */
for (n = 0; n <= RTAPI_MAX_SHMEMS; n++) {
shmem_addr_array[n] = NULL;
}
/* get the mutex */
rtapi_mutex_get(&(rtapi_data->mutex));
/* find empty spot in module array */
n = 1;
while ((n <= RTAPI_MAX_MODULES) && (module_array[n].state != NO_MODULE)) {
n++;
}
if (n > RTAPI_MAX_MODULES) {
/* no room */
rtapi_mutex_give(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_ERR,
"ULAPI:%d ERROR: reached module limit %d\n",
rtapi_instance,n);
return -EMFILE;
}
/* we have space for the module */
module_id = n;
module = &(module_array[n]);
/* update module data */
module->state = USERSPACE;
if (modname != NULL) {
/* use name supplied by caller, truncating if needed */
rtapi_snprintf(module->name, RTAPI_NAME_LEN, "%s", modname);
} else {
/* make up a name */
rtapi_snprintf(module->name, RTAPI_NAME_LEN, "ULMOD%03d", module_id);
}
rtapi_data->ul_module_count++;
rtapi_mutex_give(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_DBG, "ULAPI:%d module '%s' inited, ID = %02d\n",
rtapi_instance,module->name, module_id);
return module_id;
}
int rtapi_init(const char *modname)
{
int n, module_id;
module_data *module;
/* say hello */
rtapi_print_msg(RTAPI_MSG_DBG, "RTAPI: initing module %s\n", modname);
/* get shared memory block from OS and save its address */
errno = 0;
if(!rtapi_data)
rtapi_data = rtai_malloc(RTAPI_KEY, sizeof(rtapi_data_t));
// the check for -1 here is because rtai_malloc (in at least
// rtai 3.6.1, and probably others) has a bug where it
// sometimes returns -1 on error
if (rtapi_data == NULL || rtapi_data == (rtapi_data_t*)-1) {
rtapi_print_msg(RTAPI_MSG_ERR,
"RTAPI: ERROR: could not open shared memory (%s)\n", strerror(errno));
check_memlock_limit("could not open shared memory");
rtapi_data = 0;
return -ENOMEM;
}
nummods++;
/* perform a global init if needed */
init_rtapi_data(rtapi_data);
/* check revision code */
if (rtapi_data->rev_code != rev_code) {
/* mismatch - release master shared memory block */
rtapi_print_msg(RTAPI_MSG_ERR, "RTAPI: ERROR: version mismatch %d vs %d\n", rtapi_data->rev_code, rev_code);
return -EINVAL;
}
/* set up local pointers to global data */
module_array = rtapi_data->module_array;
task_array = rtapi_data->task_array;
shmem_array = rtapi_data->shmem_array;
sem_array = rtapi_data->sem_array;
fifo_array = rtapi_data->fifo_array;
irq_array = rtapi_data->irq_array;
/* perform local init */
for (n = 0; n <= RTAPI_MAX_SHMEMS; n++) {
shmem_addr_array[n] = NULL;
}
/* get the mutex */
rtapi_mutex_get(&(rtapi_data->mutex));
/* find empty spot in module array */
n = 1;
while ((n <= RTAPI_MAX_MODULES) && (module_array[n].state != NO_MODULE)) {
n++;
}
if (n > RTAPI_MAX_MODULES) {
/* no room */
rtapi_mutex_give(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_ERR, "RTAPI: ERROR: reached module limit %d\n",
n);
return -EMFILE;
}
/* we have space for the module */
module_id = n;
module = &(module_array[n]);
/* update module data */
module->state = USERSPACE;
if (modname != NULL) {
/* use name supplied by caller, truncating if needed */
snprintf(module->name, RTAPI_NAME_LEN, "%s", modname);
} else {
/* make up a name */
snprintf(module->name, RTAPI_NAME_LEN, "ULMOD%03d", module_id);
}
rtapi_data->ul_module_count++;
rtapi_mutex_give(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_DBG, "RTAPI: module '%s' inited, ID = %02d\n",
module->name, module_id);
return module_id;
}
/** init_hal_data() initializes the entire HAL data structure,
by the RT hal_lib component
*/
int init_hal_data(void)
{
/* has the block already been initialized? */
if (hal_data->version != 0) {
/* yes, verify version code */
if (hal_data->version == HAL_VER) {
return 0;
} else {
HALERR("version code mismatch");
return -1;
}
}
/* no, we need to init it, grab the mutex unconditionally */
rtapi_mutex_try(&(hal_data->mutex));
// some heaps contain garbage, like xenomai
memset(hal_data, 0, global_data->hal_size);
/* set version code so nobody else init's the block */
hal_data->version = HAL_VER;
/* initialize everything */
hal_data->comp_list_ptr = 0;
hal_data->pin_list_ptr = 0;
hal_data->sig_list_ptr = 0;
hal_data->param_list_ptr = 0;
hal_data->funct_list_ptr = 0;
hal_data->thread_list_ptr = 0;
hal_data->vtable_list_ptr = 0;
hal_data->base_period = 0;
hal_data->threads_running = 0;
hal_data->oldname_free_ptr = 0;
hal_data->comp_free_ptr = 0;
hal_data->pin_free_ptr = 0;
hal_data->sig_free_ptr = 0;
hal_data->param_free_ptr = 0;
hal_data->funct_free_ptr = 0;
hal_data->vtable_free_ptr = 0;
list_init_entry(&(hal_data->funct_entry_free));
hal_data->thread_free_ptr = 0;
hal_data->exact_base_period = 0;
hal_data->group_list_ptr = 0;
hal_data->member_list_ptr = 0;
hal_data->ring_list_ptr = 0;
hal_data->inst_list_ptr = 0;
hal_data->group_free_ptr = 0;
hal_data->member_free_ptr = 0;
hal_data->ring_free_ptr = 0;
hal_data->inst_free_ptr = 0;
RTAPI_ZERO_BITMAP(&hal_data->rings, HAL_MAX_RINGS);
// silly 1-based shm segment id allocation FIXED
// yeah, 'user friendly', how could one possibly think zero might be a valid id
RTAPI_BIT_SET(hal_data->rings,0);
/* set up for shmalloc_xx() */
hal_data->shmem_bot = sizeof(hal_data_t);
hal_data->shmem_top = global_data->hal_size;
hal_data->lock = HAL_LOCK_NONE;
int i;
for (i = 0; i < MAX_EPSILON; i++)
hal_data->epsilon[i] = 0.0;
hal_data->epsilon[0] = DEFAULT_EPSILON;
/* done, release mutex */
rtapi_mutex_give(&(hal_data->mutex));
return 0;
}
int rtapi_init(char *modname)
{
int n, module_id;
module_data *module;
/* say hello */
rtapi_print_msg(RTAPI_MSG_DBG, "RTAPI: initing module %s\n", modname);
/* setup revision string and code, and print opening message */
setup_revision_info();
/* get shared memory block from OS and save its address */
errno = 0;
rtapi_data = rtai_malloc(RTAPI_KEY, sizeof(rtapi_data_t));
if (rtapi_data == NULL || rtapi_data == (rtapi_data_t*)-1) {
rtapi_print_msg(RTAPI_MSG_ERR,
"RTAPI: ERROR: could not open shared memory (errno=%d)\n", errno);
return RTAPI_NOMEM;
}
/* perform a global init if needed */
init_rtapi_data(rtapi_data);
/* check revision code */
if (rtapi_data->rev_code != rev_code) {
/* mismatch - release master shared memory block */
rtapi_print_msg(RTAPI_MSG_ERR, "RTAPI: ERROR: version mismatch %d vs %d\n", rtapi_data->rev_code, rev_code);
rtai_free(RTAPI_KEY, rtapi_data);
return RTAPI_FAIL;
}
/* set up local pointers to global data */
module_array = rtapi_data->module_array;
task_array = rtapi_data->task_array;
shmem_array = rtapi_data->shmem_array;
sem_array = rtapi_data->sem_array;
fifo_array = rtapi_data->fifo_array;
irq_array = rtapi_data->irq_array;
/* perform local init */
for (n = 0; n <= RTAPI_MAX_SHMEMS; n++) {
shmem_addr_array[n] = NULL;
}
/* get the mutex */
rtapi_mutex_get(&(rtapi_data->mutex));
/* find empty spot in module array */
n = 1;
while ((n <= RTAPI_MAX_MODULES) && (module_array[n].state != NO_MODULE)) {
n++;
}
if (n > RTAPI_MAX_MODULES) {
/* no room */
rtapi_mutex_give(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_ERR, "RTAPI: ERROR: reached module limit %d\n",
n);
return RTAPI_LIMIT;
}
/* we have space for the module */
module_id = n;
module = &(module_array[n]);
/* update module data */
module->state = USERSPACE;
if (modname != NULL) {
/* use name supplied by caller, truncating if needed */
snprintf(module->name, RTAPI_NAME_LEN, "%s", modname);
} else {
/* make up a name */
snprintf(module->name, RTAPI_NAME_LEN, "ULMOD%03d", module_id);
}
rtapi_data->ul_module_count++;
rtapi_mutex_give(&(rtapi_data->mutex));
rtapi_print_msg(RTAPI_MSG_DBG, "RTAPI: module '%s' inited, ID = %02d\n",
module->name, module_id);
return module_id;
}
