static void rtmp_stream_destroy(void *data)
{
struct rtmp_stream *stream = data;
if (stopping(stream) && !connecting(stream)) {
pthread_join(stream->send_thread, NULL);
} else if (connecting(stream) || active(stream)) {
if (stream->connecting)
pthread_join(stream->connect_thread, NULL);
os_event_signal(stream->stop_event);
if (active(stream)) {
os_sem_post(stream->send_sem);
obs_output_end_data_capture(stream->output);
pthread_join(stream->send_thread, NULL);
}
}
if (stream) {
free_packets(stream);
dstr_free(&stream->path);
dstr_free(&stream->key);
dstr_free(&stream->username);
dstr_free(&stream->password);
dstr_free(&stream->encoder_name);
os_event_destroy(stream->stop_event);
os_sem_destroy(stream->send_sem);
pthread_mutex_destroy(&stream->packets_mutex);
circlebuf_free(&stream->packets);
bfree(stream);
}
}
int log_close(LOG_HANDLE ctx)
{
int ret;
if(ctx->stream.buf!=NULL) {
os_sem_post(&ctx->stream.inque);
os_thread_wait(ctx->stream.thread, NULL);
os_sem_destroy(&ctx->stream.inque);
os_sem_destroy(&ctx->stream.ouque);
os_mutex_destroy(&ctx->stream.mtx);
}
ret = map[ctx->type].func_close(ctx);
free(ctx);
return ret;
}
static void rtmp_stream_destroy(void *data)
{
struct rtmp_stream *stream = data;
if (stopping(stream) && !connecting(stream)) {
pthread_join(stream->send_thread, NULL);
} else if (connecting(stream) || active(stream)) {
if (stream->connecting)
pthread_join(stream->connect_thread, NULL);
stream->stop_ts = 0;
os_event_signal(stream->stop_event);
if (active(stream)) {
os_sem_post(stream->send_sem);
obs_output_end_data_capture(stream->output);
pthread_join(stream->send_thread, NULL);
}
}
free_packets(stream);
dstr_free(&stream->path);
dstr_free(&stream->key);
dstr_free(&stream->username);
dstr_free(&stream->password);
dstr_free(&stream->encoder_name);
dstr_free(&stream->bind_ip);
os_event_destroy(stream->stop_event);
os_sem_destroy(stream->send_sem);
pthread_mutex_destroy(&stream->packets_mutex);
circlebuf_free(&stream->packets);
#ifdef TEST_FRAMEDROPS
circlebuf_free(&stream->droptest_info);
#endif
os_event_destroy(stream->buffer_space_available_event);
os_event_destroy(stream->buffer_has_data_event);
os_event_destroy(stream->socket_available_event);
os_event_destroy(stream->send_thread_signaled_exit);
pthread_mutex_destroy(&stream->write_buf_mutex);
if (stream->write_buf)
bfree(stream->write_buf);
bfree(stream);
}
void video_output_close(video_t *video)
{
if (!video)
return;
video_output_stop(video);
for (size_t i = 0; i < video->inputs.num; i++)
video_input_free(&video->inputs.array[i]);
da_free(video->inputs);
for (size_t i = 0; i < video->info.cache_size; i++)
video_frame_free((struct video_frame*)&video->cache[i]);
os_sem_destroy(video->update_semaphore);
pthread_mutex_destroy(&video->data_mutex);
pthread_mutex_destroy(&video->input_mutex);
bfree(video);
}
void mp_media_free(mp_media_t *media)
{
if (!media)
return;
mp_media_stop(media);
mp_kill_thread(media);
mp_decode_free(&media->v);
mp_decode_free(&media->a);
avformat_close_input(&media->fmt);
pthread_mutex_destroy(&media->mutex);
os_sem_destroy(media->sem);
sws_freeContext(media->swscale);
av_freep(&media->scale_pic[0]);
bfree(media->path);
bfree(media->format_name);
memset(media, 0, sizeof(*media));
pthread_mutex_init_value(&media->mutex);
}
static void rtmp_stream_destroy(void *data)
{
struct rtmp_stream *stream = data;
if (stream->active)
rtmp_stream_stop(data);
if (stream) {
free_packets(stream);
dstr_free(&stream->path);
dstr_free(&stream->key);
dstr_free(&stream->username);
dstr_free(&stream->password);
os_event_destroy(stream->stop_event);
os_sem_destroy(stream->send_sem);
pthread_mutex_destroy(&stream->packets_mutex);
circlebuf_free(&stream->packets);
bfree(stream);
}
}
int unexport_device(const exa_uuid_t *uuid)
{
device_t *dev = find_device_from_uuid(uuid);
if (dev == NULL)
{
exalog_error("can not remove unknown device with UUID = " UUID_FMT, UUID_VAL(uuid));
return -CMD_EXP_ERR_UNKNOWN_DEVICE;
}
os_thread_mutex_lock(&nbd_server.mutex_edevs);
/* ask the thread to terminate */
dev->exit_thread = true;
/* prevent any new IO to be put in device IO list */
nbd_server.devices[dev->dev_index] = NULL;
os_thread_mutex_unlock(&nbd_server.mutex_edevs);
/* now we can join, because with the nbd_close_list()
* we can assume was the disk thread will reach a cancelation point */
os_thread_join(nbd_server.td_pid[dev->dev_index]);
/* close the list used to disk queue */
nbd_close_list(&dev->disk_queue);
/* get back all header in the kernel exa_rdev to the free list and close the device */
if (dev->handle != NULL)
exa_rdev_handle_free(dev->handle);
/* close the semaphore used by the disk */
os_sem_destroy(&dev->lock_sem_disk);
/* free used memory for the device */
os_free(dev);
return EXA_SUCCESS;
}
static inline bool reset_semaphore(struct rtmp_stream *stream)
{
os_sem_destroy(stream->send_sem);
return os_sem_init(&stream->send_sem, 0) == 0;
}
static void unmake_worker(struct worker *q)
{
os_sem_destroy(&q->done);
os_sem_destroy(&q->ready);
X(ifree)(q);
}
static void
undo_init_new_thread(struct thread *th, init_thread_data *scribble)
{
int lock_ret;
/* Kludge: Changed the order of some steps between the safepoint/
* non-safepoint versions of this code. Can we unify this more?
*/
#ifdef LISP_FEATURE_SB_SAFEPOINT
block_blockable_signals(0);
gc_alloc_update_page_tables(BOXED_PAGE_FLAG, &th->alloc_region);
#if defined(LISP_FEATURE_SB_SAFEPOINT_STRICTLY) && !defined(LISP_FEATURE_WIN32)
gc_alloc_update_page_tables(BOXED_PAGE_FLAG, &th->sprof_alloc_region);
#endif
pop_gcing_safety(&scribble->safety);
lock_ret = pthread_mutex_lock(&all_threads_lock);
gc_assert(lock_ret == 0);
unlink_thread(th);
lock_ret = pthread_mutex_unlock(&all_threads_lock);
gc_assert(lock_ret == 0);
#else
/* Block GC */
block_blockable_signals(0);
set_thread_state(th, STATE_DEAD);
/* SIG_STOP_FOR_GC is blocked and GC might be waiting for this
* thread, but since we are already dead it won't wait long. */
lock_ret = pthread_mutex_lock(&all_threads_lock);
gc_assert(lock_ret == 0);
gc_alloc_update_page_tables(BOXED_PAGE_FLAG, &th->alloc_region);
#if defined(LISP_FEATURE_SB_SAFEPOINT_STRICTLY) && !defined(LISP_FEATURE_WIN32)
gc_alloc_update_page_tables(BOXED_PAGE_FLAG, &th->sprof_alloc_region);
#endif
unlink_thread(th);
pthread_mutex_unlock(&all_threads_lock);
gc_assert(lock_ret == 0);
#endif
arch_os_thread_cleanup(th);
#ifndef LISP_FEATURE_SB_SAFEPOINT
os_sem_destroy(th->state_sem);
os_sem_destroy(th->state_not_running_sem);
os_sem_destroy(th->state_not_stopped_sem);
#endif
#ifdef LISP_FEATURE_MACH_EXCEPTION_HANDLER
mach_lisp_thread_destroy(th);
#endif
#if defined(LISP_FEATURE_WIN32)
int i;
for (i = 0; i<
(int) (sizeof(th->private_events.events)/
sizeof(th->private_events.events[0])); ++i) {
CloseHandle(th->private_events.events[i]);
}
TlsSetValue(OUR_TLS_INDEX,NULL);
#endif
/* Undo the association of the current pthread to its `struct thread',
* such that we can call arch_os_get_current_thread() later in this
* thread and cleanly get back NULL. */
#ifdef LISP_FEATURE_GCC_TLS
current_thread = NULL;
#else
pthread_setspecific(specials, NULL);
#endif
}
~MbedRawUSBSerial()
{
os_sem_destroy(&rxSem);
}
os_result
os_procCreate(
const char *executable_file,
const char *name,
const char *arguments,
os_procAttr *procAttr,
os_procId *procId)
{
int procTaskId;
int sched_policy;
os_result rv = os_resultSuccess;
os_procContextData process_procContextData;
os_int32 startRoutine = 0;
os_int32 pOptions,privateSet;
os_int32 len,i=0,n=0;
char *converted = NULL;
assert(executable_file != NULL);
assert(name != NULL);
assert(arguments != NULL);
assert(procAttr != NULL);
assert(procId != NULL);
len = strlen(arguments);
converted = (char*)os_malloc(len+1);
for (; i < len ; i++)
{
if (arguments[i] != '\"')
{
converted[n] = arguments[i];
n++;
}
}
converted[n] = '\0';
pOptions = 0;
privateSet = 0;
taskOptionsGet(taskIdSelf(),&pOptions);
if ((pOptions & VX_PRIVATE_ENV) == 0)
{
envPrivateCreate(taskIdSelf(), 0);
privateSet = 1;
}
putenv("SPLICE_NEW_PROCESS=no");
if (procAttr->schedClass == OS_SCHED_REALTIME) {
sched_policy = SCHED_FIFO;
} else if (procAttr->schedClass == OS_SCHED_TIMESHARE) {
return os_resultInvalid;
} else if (procAttr->schedClass == OS_SCHED_DEFAULT) {
sched_policy = SCHED_OTHER;
} else {
return os_resultInvalid;
}
if ((procAttr->schedPriority > VXWORKS_PRIORITY_MIN) ||
(procAttr->schedPriority < VXWORKS_PRIORITY_MAX) ) {
return os_resultInvalid;
}
{
os_library binlib;
os_libraryAttr attr;
os_libraryAttrInit(&attr);
/* Dynamic load of services is a special case, so try just static via
os_libraryOpen */
attr.staticLibOnly=1;
binlib = os_libraryOpen( executable_file, &attr);
/* FIXME existing use of os_int32 for pointer is CRAZY!! */
if ( binlib != NULL )
{
startRoutine = (os_int32)os_libraryGetSymbol( binlib, executable_file );
}
if ( startRoutine == 0 && os_dynamicLibPlugin != NULL )
{
startRoutine = (os_uint32)os_dynamicLibPlugin->dlp_loadLib( executable_file );
}
if ( startRoutine == 0 )
{
OS_REPORT(OS_ERROR, "os_procCreate", 1,
"Unable to load %s (%s)",
executable_file, name);
rv = os_resultInvalid;
}
}
if (rv == os_resultSuccess)
{
process_procContextData = (os_procContextData )os_malloc((size_t)OS_SIZEOF(os_procContextData));
if (process_procContextData == (os_procContextData) NULL) {
OS_REPORT(OS_WARNING, "os_procCreate", 1,
"malloc failed with error %d (%s, %s)",
os_getErrno(), executable_file, name);
rv = os_resultInvalid;
}
else
{
#if defined ( _WRS_VXWORKS_MAJOR ) && ( _WRS_VXWORKS_MAJOR > 6 ) || ( _WRS_VXWORKS_MAJOR == 6 && _WRS_VXWORKS_MINOR > 8 )
/* the blockParent semaphore is used to prevent this task exiting before the spawned task
has completed copying its environ. */
os_sem_t blockParent;
os_sem_init( &blockParent, 0);
#endif
os_procInit(process_procContextData, name, executable_file, converted);
process_procContextData->procAttrPrio = procAttr->schedPriority;
procTaskId = taskSpawn((char *)name, procAttr->schedPriority,
VX_FP_TASK
#if ! defined ( _WRS_VXWORKS_MAJOR ) || _WRS_VXWORKS_MAJOR < 6 || ( _WRS_VXWORKS_MAJOR == 6 && _WRS_VXWORKS_MINOR < 9 )
/* VX_PRIVATE_ENV flag is no longer functional in vxworks 6.9 */
| VX_PRIVATE_ENV
#endif
#if defined ( VXWORKS_55 ) || defined ( VXWORKS_54 )
| VX_STDIO | VX_DEALLOC_STACK
#endif
,
VXWORKS_PROC_DEFAULT_STACK,
(FUNCPTR)os_procWrapper,
(int)process_procContextData, (int)process_procContextData->executable,
(int)startRoutine, (int)process_procContextData->arguments, taskIdSelf(),
#if ! defined ( _WRS_VXWORKS_MAJOR ) || _WRS_VXWORKS_MAJOR < 6 || ( _WRS_VXWORKS_MAJOR == 6 && _WRS_VXWORKS_MINOR < 9 )
0,
#else
&blockParent,
#endif
0, 0, 0, 0);
#if defined ( _WRS_VXWORKS_MAJOR ) && ( _WRS_VXWORKS_MAJOR > 6 || ( _WRS_VXWORKS_MAJOR == 6 && _WRS_VXWORKS_MINOR > 8 ) )
os_sem_wait(&blockParent);
os_sem_destroy(&blockParent);
#endif
if (procTaskId == ERROR)
{
os_free(process_procContextData);
rv = os_resultInvalid;
}
else
{
*procId = *(os_procId *)&process_procContextData;
rv = os_resultSuccess;
}
}
}
putenv("SPLICE_NEW_PROCESS=empty");
if ( privateSet == 1)
{
envPrivateDestroy(taskIdSelf());
}
os_free(converted);
return rv;
}
/* A new device is handled by the server, do the init operations in order to make the device usable */
int export_device(const exa_uuid_t *uuid, char *device_path)
{
device_t *dev;
int i, err;
/* If device was already exported, do nothing */
if (find_device_from_uuid(uuid) != NULL)
return EXA_SUCCESS;
dev = os_malloc(sizeof(struct device));
if (dev == NULL)
{
err = -NBD_ERR_MALLOC_FAILED;
goto error;
}
dev->handle = NULL;
err = -CMD_EXP_ERR_OPEN_DEVICE;
dev->handle = exa_rdev_handle_alloc(device_path);
if (dev->handle == NULL)
goto error;
err = get_nb_sectors(device_path, &dev->size_in_sectors);
if (err != EXA_SUCCESS)
goto error;
uuid_copy(&dev->uuid, uuid);
strlcpy(dev->path, device_path, sizeof(dev->path));
for (i = 0; i < NBMAX_DISKS_PER_NODE; i++)
if (nbd_server.devices[i] == NULL)
break;
if (i >= NBMAX_DISKS_PER_NODE)
{
exalog_error("maximum number of exportable devices exceeded");
err = -NBD_ERR_NB_RDEVS_CREATED;
}
dev->dev_index = i;
dev->exit_thread = false;
nbd_init_list(&nbd_server.list_root, &dev->disk_queue);
/* resource needed to lock/unlock a zone */
os_sem_init (&dev->lock_sem_disk, 0);
/* launch disk thread (TD) */
if (!exathread_create_named(&nbd_server.td_pid[dev->dev_index],
NBD_THREAD_STACK_SIZE + MIN_THREAD_STACK_SIZE,
exa_td_main, dev, "TD_thread"))
{
os_sem_destroy(&dev->lock_sem_disk);
err = -NBD_ERR_THREAD_CREATION;
goto error;
}
nbd_server.devices[dev->dev_index] = dev;
return EXA_SUCCESS;
error:
if (dev != NULL)
{
if (dev->handle != NULL)
exa_rdev_handle_free(dev->handle);
os_free(dev);
}
return err;
}
