static
void
globus_l_xio_win32_socket_complete(
globus_i_xio_system_op_info_t * op_info,
globus_bool_t win32_thread)
{
SOCKET fd;
globus_result_t result;
GlobusXIOName(globus_l_xio_win32_socket_complete);
fd = op_info->handle->socket;
GlobusXIOSystemDebugEnterFD(fd);
if(!op_info->op)
{
/* internal usage */
globus_l_xio_win32_socket_kickout(op_info);
result = GLOBUS_SUCCESS;
}
else if(win32_thread)
{
result = globus_i_xio_win32_complete(
globus_l_xio_win32_socket_kickout, op_info);
}
else
{
result = globus_callback_register_oneshot(
0, 0, globus_l_xio_win32_socket_kickout, op_info);
}
/* really cant do anything else */
if(result != GLOBUS_SUCCESS)
{
globus_panic(
GLOBUS_XIO_SYSTEM_MODULE,
result,
_XIOSL("[%s:%d] Couldn't register callback"),
_xio_name,
__LINE__);
}
GlobusXIOSystemDebugExitFD(fd);
}
static
void
globus_l_xio_win32_socket_cancel_cb(
globus_xio_operation_t op,
void * user_arg,
globus_xio_error_type_t reason)
{
globus_i_xio_system_op_info_t * op_info;
GlobusXIOName(globus_l_xio_win32_socket_cancel_cb);
GlobusXIOSystemDebugEnter();
op_info = (globus_i_xio_system_op_info_t *) user_arg;
/* this access of the handle is not safe if users destroy it
* with outstanding callbacks. I don't think that is allowed, so we
* should be ok.
*/
win32_mutex_lock(&op_info->handle->lock);
{
if(op_info->state != GLOBUS_I_XIO_SYSTEM_OP_COMPLETE &&
op_info->state != GLOBUS_I_XIO_SYSTEM_OP_CANCELED)
{
op_info->error = reason == GLOBUS_XIO_ERROR_TIMEOUT
? GlobusXIOErrorObjTimeout()
: GlobusXIOErrorObjCanceled();
if(op_info->state == GLOBUS_I_XIO_SYSTEM_OP_NEW)
{
op_info->state = GLOBUS_I_XIO_SYSTEM_OP_CANCELED;
GlobusXIOSystemDebugPrintf(
GLOBUS_I_XIO_SYSTEM_DEBUG_INFO,
("[%s] fd=%lu, Canceling NEW\n",
_xio_name, (unsigned long)op_info->handle->socket));
}
else
{
globus_result_t result;
op_info->state = GLOBUS_I_XIO_SYSTEM_OP_COMPLETE;
GlobusXIOSystemDebugPrintf(
GLOBUS_I_XIO_SYSTEM_DEBUG_INFO,
("[%s] fd=%lu, Canceling Pending\n",
_xio_name, (unsigned long)op_info->handle->socket));
if(op_info->handle->read_info == op_info)
{
op_info->handle->read_info = 0;
}
else
{
globus_assert(op_info->handle->write_info == op_info);
op_info->handle->write_info = 0;
}
/* unregister and kickout now */
result = globus_callback_register_oneshot(
0,
0,
globus_l_xio_win32_socket_kickout,
op_info);
/* really cant do anything else */
if(result != GLOBUS_SUCCESS)
{
globus_panic(
GLOBUS_XIO_SYSTEM_MODULE,
result,
_XIOSL("[%s:%d] Couldn't register callback"),
_xio_name,
__LINE__);
}
}
}
}
win32_mutex_unlock(&op_info->handle->lock);
GlobusXIOSystemDebugExit();
}
void
globus_i_gsc_event_start_perf_restart(
globus_i_gsc_op_t * op)
{
globus_result_t res;
globus_reltime_t delay;
globus_i_gsc_event_data_t * event;
event = &op->event;
if(op->type != GLOBUS_L_GSC_OP_TYPE_RECV && op->type != GLOBUS_L_GSC_OP_TYPE_SEND)
{
return;
}
/* performance markers */
if(((op->type == GLOBUS_L_GSC_OP_TYPE_RECV &&
op->server_handle->opts.perf_frequency > 0) ||
(op->type == GLOBUS_L_GSC_OP_TYPE_SEND &&
op->server_handle->opts.retr_perf_frequency > 0)) &&
event->event_mask & GLOBUS_GRIDFTP_SERVER_CONTROL_EVENT_PERF)
{
event->stripe_count = op->server_handle->stripe_count;
event->stripe_total = (globus_off_t *)globus_calloc(
sizeof(globus_off_t) * event->stripe_count, 1);
/* register periodic for events */
if(op->type == GLOBUS_L_GSC_OP_TYPE_SEND)
{
GlobusTimeReltimeSet(
delay, op->server_handle->opts.retr_perf_frequency, 0);
}
else
{
GlobusTimeReltimeSet(
delay, op->server_handle->opts.perf_frequency, 0);
}
event->perf_running = GLOBUS_TRUE;
res = globus_callback_register_periodic(
&event->periodic_handle,
&delay,
&delay,
globus_l_gsc_send_perf_marker_cb,
op);
if(res != GLOBUS_SUCCESS)
{
globus_panic(&globus_i_gsc_module, res, "one shot failed.");
}
}
/* restart markers */
if(op->server_handle->opts.restart_frequency > 0 &&
event->event_mask & GLOBUS_GRIDFTP_SERVER_CONTROL_EVENT_RESTART &&
op->type == GLOBUS_L_GSC_OP_TYPE_RECV)
{
GlobusTimeReltimeSet(
delay, op->server_handle->opts.restart_frequency, 0);
event->restart_running = GLOBUS_TRUE;
res = globus_callback_register_periodic(
&event->restart_handle,
&delay,
&delay,
globus_l_gsc_send_restart_marker_cb,
op);
if(res != GLOBUS_SUCCESS)
{
globus_panic(&globus_i_gsc_module, res, "one shot failed.");
}
}
}
