static void globus_l_gram_streamer_data_callback( void * arg, globus_gass_transfer_request_t request, globus_byte_t * bytes, globus_size_t length, globus_bool_t last_data) { globus_gram_streamer_monitor_t * monitor = arg; globus_gram_stream_t * stream; globus_gass_transfer_request_status_t status; globus_mutex_lock(&monitor->mutex); stream = globus_gass_transfer_request_get_user_pointer(request); free(bytes); stream->blocks--; status = globus_gass_transfer_request_get_status(request); if (last_data && stream->blocks == 0) { switch (status) { case GLOBUS_GASS_TRANSFER_REQUEST_INVALID: case GLOBUS_GASS_TRANSFER_REQUEST_STARTING: case GLOBUS_GASS_TRANSFER_REQUEST_FAILED: case GLOBUS_GASS_TRANSFER_REQUEST_DENIED: case GLOBUS_GASS_TRANSFER_REQUEST_REFERRED: globus_gass_transfer_request_destroy(request); if (stream->state != GLOBUS_GRAM_STREAM_RESTART) { stream->state = GLOBUS_GRAM_STREAM_FAIL; globus_cond_signal(&monitor->cond); } break; case GLOBUS_GASS_TRANSFER_REQUEST_DONE: globus_gass_transfer_request_destroy(request); if (stream->state == GLOBUS_GRAM_STREAM_ACTIVE) { stream->state = GLOBUS_GRAM_STREAM_DONE; } globus_cond_signal(&monitor->cond); break; case GLOBUS_GASS_TRANSFER_REQUEST_PENDING: break; default: fprintf(stderr, "%d:GASS Transfer returned invalid status: %d\n", GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED, (int) status); exit(EXIT_FAILURE); } } globus_mutex_unlock(&monitor->mutex); }
static void globus_l_gram_streamer_request_ready( void * arg, globus_gass_transfer_request_t request) { globus_gram_streamer_monitor_t * monitor = arg; globus_gram_stream_t * stream; globus_gass_transfer_request_status_t status; globus_mutex_lock(&monitor->mutex); stream = globus_gass_transfer_request_get_user_pointer(request); status = globus_gass_transfer_request_get_status(request); switch (status) { case GLOBUS_GASS_TRANSFER_REQUEST_INVALID: case GLOBUS_GASS_TRANSFER_REQUEST_STARTING: globus_gass_transfer_request_destroy(request); stream->state = GLOBUS_GRAM_STREAM_FAIL; globus_cond_signal(&monitor->cond); break; case GLOBUS_GASS_TRANSFER_REQUEST_FAILED: case GLOBUS_GASS_TRANSFER_REQUEST_DENIED: globus_gass_transfer_request_destroy(request); stream->state = GLOBUS_GRAM_STREAM_FAIL; globus_cond_signal(&monitor->cond); break; case GLOBUS_GASS_TRANSFER_REQUEST_REFERRED: globus_gass_transfer_request_destroy(request); stream->state = GLOBUS_GRAM_STREAM_DONE; globus_cond_signal(&monitor->cond); break; case GLOBUS_GASS_TRANSFER_REQUEST_DONE: globus_gass_transfer_request_destroy(request); stream->state = GLOBUS_GRAM_STREAM_DONE; globus_cond_signal(&monitor->cond); break; case GLOBUS_GASS_TRANSFER_REQUEST_PENDING: stream->state = GLOBUS_GRAM_STREAM_ACTIVE; break; default: fprintf(stderr, "%d:GASS Transfer returned invalid status: %d\n", GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED, (int) status); exit(EXIT_FAILURE); } globus_mutex_unlock(&monitor->mutex); }
/** * @brief Determine if the job's processes are still running * * The globus_l_gram_streamer_waitpids() function is called periodically to * check whether the pids associated with this streamer are still running. * If they are all complete, globus_l_gram_streamer_waitpids() will signal * the main thread and disable this callback from being called again. */ static void globus_l_gram_streamer_waitpids( void * arg) { int i; globus_gram_streamer_monitor_t * monitor = arg; globus_mutex_lock(&monitor->mutex); for (i = 0; i < STREAMER_MAX; i++) { if (monitor->pids[i] == 0) { continue; } if (kill(monitor->pids[i], 0) == -1) { monitor->pids[i] = 0; monitor->pid_count--; } } if (monitor->pid_count == 0) { globus_cond_signal(&monitor->cond); globus_callback_unregister( monitor->waitpids_poll_periodic, NULL, NULL, NULL); } globus_mutex_unlock(&monitor->mutex); }
void test2_writev_callback( void * callback_arg, globus_io_handle_t * handle, globus_result_t result, struct iovec * iov, globus_size_t iovcnt, globus_size_t nbytes) { globus_object_t * err = GLOBUS_NULL; test_monitor_t * monitor; monitor = (test_monitor_t *) callback_arg; if(result != GLOBUS_SUCCESS) { err = globus_error_get(result); } globus_mutex_lock(&monitor->mutex); if(result != GLOBUS_SUCCESS && !globus_io_eof(err)) { monitor->use_err = GLOBUS_TRUE; monitor->err = err; } monitor->done = GLOBUS_TRUE; globus_cond_signal(&monitor->cond); globus_mutex_unlock(&monitor->mutex); return; }
static void globus_l_gfs_sigint( void * user_arg) { GlobusGFSName(globus_l_gfs_sigint); GlobusGFSDebugEnter(); globus_mutex_lock(&globus_l_gfs_mutex); { if(globus_l_gfs_sigint_caught) { globus_l_gfs_server_active = 0; } globus_l_gfs_sigint_caught = GLOBUS_TRUE; globus_l_gfs_terminated = GLOBUS_TRUE; if(!globus_l_gfs_server_active) { globus_cond_signal(&globus_l_gfs_cond); } else { globus_libc_printf("Embedded server stopping.\n"); globus_gridftp_server_embed_stop(globus_l_gfs_server_handle); } } globus_mutex_unlock(&globus_l_gfs_mutex); GlobusGFSDebugExit(); }
void test1_read_callback( void * callback_arg, globus_io_handle_t * handle, globus_result_t result, globus_byte_t * buf, globus_size_t nbytes) { globus_object_t * err; test_monitor_t * monitor; monitor = (test_monitor_t *) callback_arg; if(result != GLOBUS_SUCCESS) { err = globus_error_get(result); } globus_mutex_lock(&monitor->mutex); if(result != GLOBUS_SUCCESS && !globus_io_eof(err)) { monitor->use_err = GLOBUS_TRUE; monitor->err = err; } buf[nbytes >= test_buffer_size ? test_buffer_size-1 : nbytes] = '\0'; monitor->done = GLOBUS_TRUE; globus_cond_signal(&monitor->cond); globus_mutex_unlock(&monitor->mutex); return; }
static void example_submit_callback( void * user_callback_arg, globus_gram_protocol_error_t operation_failure_code, const char * job_contact, globus_gram_protocol_job_state_t job_state, globus_gram_protocol_error_t job_failure_code) { struct monitor_t * monitor = user_callback_arg; globus_mutex_lock(&monitor->mutex); monitor->done = GLOBUS_TRUE; globus_cond_signal(&monitor->cond); if (operation_failure_code == GLOBUS_SUCCESS) { printf("Submitted job %s\n", job_contact ? job_contact : "UNKNOWN"); } else { printf("submit failed because %s (Error %d)\n", globus_gram_client_error_string(operation_failure_code), operation_failure_code); } globus_mutex_unlock(&monitor->mutex); }
/** * @brief Unlock a recursive mutex * @ingroup globus_mutex * * @details * The globus_rmutex_unlock() function decrements the lock count for * the lock pointed to by @a rmutex. If the lock count is reduced to * zero, it also unblocks a thread which is trying to acquire the lock * if there is one. * * @param rmutex * Mutex to unlock * * @return GLOBUS_SUCCESS */ int globus_rmutex_unlock( globus_rmutex_t * rmutex) { globus_mutex_lock(&rmutex->mutex); { /* I don't fail here because this is being used with libtool and it * unlocks a mutex that was never locked */ if(rmutex->level > 0) { globus_assert( globus_thread_equal(rmutex->thread_id, globus_thread_self())); rmutex->level--; if(rmutex->level == 0) { memset(&rmutex->thread_id,0,sizeof(rmutex->thread_id)); if(rmutex->waiting) { globus_cond_signal(&rmutex->cond); } } } } globus_mutex_unlock(&rmutex->mutex); return 0; }
void test1_connect_callback( void * callback_arg, globus_io_handle_t * handle, globus_result_t result) { globus_object_t * err; test_monitor_t * monitor; monitor = (test_monitor_t *) callback_arg; if(result != GLOBUS_SUCCESS) { err = globus_error_get(result); } globus_mutex_lock(&monitor->mutex); if(result != GLOBUS_SUCCESS) { monitor->use_err = GLOBUS_TRUE; monitor->err = err; } monitor->done = GLOBUS_TRUE; globus_cond_signal(&monitor->cond); globus_mutex_unlock(&monitor->mutex); return; }
static void wakeup_func( void * arg) { globus_mutex_lock(&mutex); done = GLOBUS_TRUE; globus_cond_signal(&cond); globus_mutex_unlock(&mutex); }
static void test_l_gram_callback( void * callback_arg, char * job_contact, int state, int errorcode) { test_monitor_t *monitor = callback_arg; globus_mutex_lock(&monitor->mutex); monitor->failure_code = errorcode; switch (monitor->status) { case GLOBUS_GRAM_PROTOCOL_JOB_STATE_UNSUBMITTED: monitor->status = state; break; case GLOBUS_GRAM_PROTOCOL_JOB_STATE_STAGE_IN: if (state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_UNSUBMITTED) { monitor->status = state; } case GLOBUS_GRAM_PROTOCOL_JOB_STATE_PENDING: if (state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_UNSUBMITTED && state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_STAGE_IN) { monitor->status = state; } break; case GLOBUS_GRAM_PROTOCOL_JOB_STATE_ACTIVE: if (state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_UNSUBMITTED && state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_PENDING && state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_STAGE_IN) { monitor->status = state; } break; case GLOBUS_GRAM_PROTOCOL_JOB_STATE_STAGE_OUT: if (state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_UNSUBMITTED && state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_PENDING && state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_STAGE_IN && state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_ACTIVE) { monitor->status = state; } break; case GLOBUS_GRAM_PROTOCOL_JOB_STATE_FAILED: case GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE: case GLOBUS_GRAM_PROTOCOL_JOB_STATE_ALL: case GLOBUS_GRAM_PROTOCOL_JOB_STATE_SUSPENDED: break; } globus_cond_signal(&monitor->cond); globus_mutex_unlock(&monitor->mutex); }
static void touch_ctl_cb(void *myargs, globus_ftp_client_handle_t *handle, globus_object_t *error) { if (error) { FPRINTF(stderr, "%s\n", globus_object_printable_to_string(error)); } globus_mutex_lock(&lock); touch_ctl_done=GLOBUS_TRUE; globus_cond_signal(&cond); globus_mutex_unlock(&lock); }
void * consumer( void * nitems_arg) { int i; long nitems; prod_data_t * data; long thread_id; nitems = (long) nitems_arg; thread_id_assign(); thread_id = thread_id_get(); wait_for_all(); for (i = 0; i < nitems ; i++) { globus_mutex_lock(&queue_mutex); { while(globus_fifo_empty(&queue)) { # if (DEBUG_LEVEL > 1) { globus_stdio_lock(); { printf("%04ld: consumer() - waiting for data item %d\n", thread_id, i); } globus_stdio_unlock(); } # endif globus_cond_wait(&queue_cond, &queue_mutex); } data = globus_fifo_dequeue(&queue); } globus_mutex_unlock(&queue_mutex); globus_mutex_lock(&data->mutex); { data->done = GLOBUS_TRUE; globus_cond_signal(&data->cond); } globus_mutex_unlock(&data->mutex); } wait_for_all(); return NULL; }
void signal_exit() { verbose_printf(2, "signal_exit() : start\n"); globus_mutex_lock(&monitor.mutex); { monitor.done = GLOBUS_TRUE; monitor.count++; globus_cond_signal(&monitor.cond); } globus_mutex_unlock(&monitor.mutex); }
/** * Callback for writing event to scheduler. * * @param handle * @param result * @param iovec * @param count * @param nbytes * @param data_desc * @param user_arg */ static void globus_l_seg_writev_callback( globus_xio_handle_t handle, globus_result_t result, globus_xio_iovec_t * iovec, int count, globus_size_t nbytes, globus_xio_data_descriptor_t data_desc, void * user_arg) { int i; globus_bool_t trigger_fault = GLOBUS_FALSE; globus_bool_t reregister_write = GLOBUS_FALSE; int do_shutdown = 0; for (i = 0; i < count; i++) { globus_libc_free(iovec[i].iov_base); } globus_libc_free(iovec); globus_mutex_lock(&globus_l_seg_mutex); globus_l_seg_write_registered = GLOBUS_FALSE; if (result != GLOBUS_SUCCESS) { trigger_fault = GLOBUS_TRUE; } else if (!globus_fifo_empty(&globus_l_seg_buffers)) { reregister_write = GLOBUS_TRUE; } else if (globus_l_seg_shutdown) { do_shutdown = 1; } if (trigger_fault) { globus_scheduler_event_generator_fault(result); } if (reregister_write) { globus_l_seg_register_write(NULL); } if (do_shutdown) { globus_l_seg_shutdown = 2; globus_cond_signal(&globus_l_seg_cond); } globus_mutex_unlock(&globus_l_seg_mutex); }
static void writediscontig_ctl_cb(void *myargs, globus_ftp_client_handle_t *handle, globus_object_t *error) { if (error) { FPRINTF(stderr, "%s\n", globus_object_printable_to_string(error)); } globus_mutex_lock(&writediscontig_ctl_lock); if ( writediscontig_ctl_done!=GLOBUS_TRUE ) writediscontig_ctl_done=GLOBUS_TRUE; globus_cond_signal(&writediscontig_ctl_cond); globus_mutex_unlock(&writediscontig_ctl_lock); return; }
void abort_cb( globus_gridftp_server_control_op_t op, int event_type, void * user_arg) { globus_mutex_lock(&gs_l_mutex); { globus_l_done = GLOBUS_TRUE; globus_cond_signal(&gs_l_cond); } globus_mutex_unlock(&gs_l_mutex); }
static void done_cb( void * user_arg, globus_ftp_client_handle_t * handle, globus_object_t * err) { if(err){ fprintf(stderr, "%s", globus_object_printable_to_string(err)); } globus_mutex_lock(&lock); done = GLOBUS_TRUE; globus_cond_signal(&cond); globus_mutex_unlock(&lock); return; }
void * server_func( void * arg) { struct thread_arg * thread_args; globus_bool_t authenticated; gss_ctx_id_t context_handle = GSS_C_NO_CONTEXT; char * user_id = NULL; gss_cred_id_t credential = GSS_C_NO_CREDENTIAL; gss_cred_id_t delegated_cred = GSS_C_NO_CREDENTIAL; thread_args = (struct thread_arg *) arg; authenticated = globus_gsi_gssapi_test_authenticate( thread_args->fd, GLOBUS_TRUE, thread_args->credential, &context_handle, &user_id, &delegated_cred); if(authenticated == GLOBUS_FALSE) { fprintf(stderr, "SERVER: Authentication failed\n"); } close(thread_args->fd); free(thread_args); globus_gsi_gssapi_test_cleanup(&context_handle, user_id, &delegated_cred); globus_mutex_lock(&mutex); { server_thread_count--; if(server_thread_count == 0) { globus_cond_signal(&done); } } globus_mutex_unlock(&mutex); return NULL; }
static void globus_l_done_cb( globus_gridftp_server_control_t server, globus_result_t res, void * user_arg) { fprintf(stdout, "Done callback received\n"); test_res(res, __LINE__); globus_mutex_lock(&globus_l_mutex); { globus_l_done = GLOBUS_TRUE; globus_cond_signal(&globus_l_cond); } globus_mutex_unlock(&globus_l_mutex); }
static void writecontig_ctl_cb(void *myargs, globus_ftp_client_handle_t *handle, globus_object_t *error) { if (error) { FPRINTF(stderr, "%s\n", globus_object_printable_to_string(error)); } globus_mutex_lock(&writecontig_ctl_lock); if ( writecontig_ctl_done!=GLOBUS_TRUE ) writecontig_ctl_done=GLOBUS_TRUE; globus_cond_signal(&writecontig_ctl_cond); globus_mutex_unlock(&writecontig_ctl_lock); #ifdef PRINT_ERR_MSG FPRINTF(stderr,"finished with contig write transaction\n"); #endif /* PRINT_ERR_MSG */ return; }
/* * globus_l_module_mutex_unlock() */ static void globus_l_module_mutex_unlock( globus_l_module_mutex_t * mutex) { globus_mutex_lock(&mutex->mutex); { globus_assert(mutex->level > 0); globus_assert( globus_thread_equal( mutex->thread_id, globus_thread_self() ) ); mutex->level--; if (mutex->level == 0) { globus_cond_signal(&mutex->cond); } } globus_mutex_unlock(&mutex->mutex); }
static void close_cb( globus_xio_handle_t handle, globus_result_t result, void * user_arg) { test_info_t * info; info = (test_info_t *) user_arg; globus_mutex_lock(&globus_l_mutex); { globus_l_closed = GLOBUS_TRUE; globus_cond_signal(&globus_l_cond); } globus_mutex_unlock(&globus_l_mutex); }
static void globus_l_state_callback( void * callback_arg, char * job_contact, int state, int errorcode) { monitor_t * monitor = callback_arg; globus_mutex_lock(&monitor->mutex); if (! strcmp(monitor->job_contact, job_contact)) { monitor->job_status = state; globus_cond_signal(&monitor->cond); } globus_mutex_unlock(&monitor->mutex); }
static void gram_state_callback( void * arg, char * job_contact, int state, int errorcode) { monitor_t * monitor; monitor = arg; globus_mutex_lock(&monitor->mutex); monitor->state = state; monitor->errorcode = errorcode; globus_cond_signal(&monitor->cond); globus_mutex_unlock(&monitor->mutex); }
static void client_callback( void * arg, globus_gram_protocol_handle_t handle, globus_byte_t * message, globus_size_t msgsize, int errorcode, char * uri) { monitor_t * monitor; int rc; monitor = (monitor_t *) arg; globus_mutex_lock(&monitor->mutex); if (errorcode != GLOBUS_SUCCESS) { fprintf(stderr, "Failed connecting to service because %s.\n", globus_gram_protocol_error_string(errorcode)); monitor->error++; goto failed; } rc = globus_gram_protocol_unpack_status_reply( message, msgsize, &monitor->job_status[0], &monitor->failure_code[0], &monitor->job_failure_code[0]); if(rc != GLOBUS_SUCCESS) { fprintf(stderr, "Failed unpacking reply because %s.\n", globus_gram_protocol_error_string(rc)); monitor->error++; } failed: monitor->done = GLOBUS_TRUE; globus_cond_signal(&monitor->cond); globus_mutex_unlock(&monitor->mutex); }
static void done_cb( void * user_arg, globus_ftp_client_handle_t * handle, globus_object_t * err) { char * tmpstr; if(err) { tmpstr = globus_object_printable_to_string(err); printf("done with error: %s\n", tmpstr); error = GLOBUS_TRUE; globus_libc_free(tmpstr); } globus_mutex_lock(&lock); done = GLOBUS_TRUE; globus_cond_signal(&cond); globus_mutex_unlock(&lock); }
static void info_callback( void * user_callback_arg, const char * job_contact, globus_gram_client_job_info_t * job_info) { struct monitor * monitor = user_callback_arg; if (monitor) { globus_mutex_lock(&monitor->mutex); monitor->job_state = job_info->job_state; monitor->protocol_error_code = job_info->protocol_error_code; monitor->done = GLOBUS_TRUE; globus_cond_signal(&monitor->cond); globus_mutex_unlock(&monitor->mutex); } }
static void done_cb( void * user_arg, globus_ftp_client_handle_t * handle, globus_object_t * err) { char * tmpstr; if(err) tmpstr = " an"; else tmpstr = "out"; printf("done with%s error\n", tmpstr); globus_mutex_lock(&lock); done = GLOBUS_TRUE; globus_cond_signal(&cond); globus_mutex_unlock(&lock); }
void list_read_data_callback( void * callback_arg, globus_ftp_control_handle_t * handle, globus_object_t * error, globus_byte_t * buffer, globus_size_t length, globus_off_t offset, globus_bool_t eof) { get_put_info_t * get_put_info; get_put_info = (get_put_info_t *) callback_arg; if(error != GLOBUS_NULL) { verbose_printf(1, "unable to list files\n"); monitor.rc = GLOBUS_FALSE; signal_exit(); } buffer[length] = '\0'; verbose_printf(3, "%s", buffer); if (!eof) { globus_ftp_control_data_read( handle, get_put_info->buffer, get_put_info->buffer_size, list_read_data_callback, (void *) get_put_info); } else { verbose_printf(2, "we have eof\n"); globus_mutex_lock(&data_monitor.mutex); { data_monitor.done = GLOBUS_TRUE; globus_cond_signal(&data_monitor.cond); } globus_mutex_unlock(&data_monitor.mutex); } }