← Back to branch summary

~ubuntu-branches/ubuntu/wily/qemu-kvm-spice/wily

« back to all changes in this revision

Viewing changes to qemu-thread-posix.c

  • Committer: Bazaar Package Importer
  • Author(s): Serge Hallyn
  • Date: 2011-10-19 10:44:56 UTC
  • Revision ID: james.westby@ubuntu.com-20111019104456-xgvskumk3sxi97f4
Tags: upstream-0.15.0+noroms
Import upstream version 0.15.0+noroms

Show diffs side-by-side

added added

removed removed

Lines of Context:
qemu-thread-posix.c
 
1
/*
 
2
 * Wrappers around mutex/cond/thread functions
 
3
 *
 
4
 * Copyright Red Hat, Inc. 2009
 
5
 *
 
6
 * Author:
 
7
 *  Marcelo Tosatti <mtosatti@redhat.com>
 
8
 *
 
9
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
 
10
 * See the COPYING file in the top-level directory.
 
11
 *
 
12
 */
 
13
#include <stdlib.h>
 
14
#include <stdio.h>
 
15
#include <errno.h>
 
16
#include <time.h>
 
17
#include <signal.h>
 
18
#include <stdint.h>
 
19
#include <string.h>
 
20
#include "qemu-thread.h"
 
21
 
 
22
static void error_exit(int err, const char *msg)
 
23
{
 
24
    fprintf(stderr, "qemu: %s: %s\n", msg, strerror(err));
 
25
    exit(1);
 
26
}
 
27
 
 
28
void qemu_mutex_init(QemuMutex *mutex)
 
29
{
 
30
    int err;
 
31
    pthread_mutexattr_t mutexattr;
 
32
 
 
33
    pthread_mutexattr_init(&mutexattr);
 
34
    pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_ERRORCHECK);
 
35
    err = pthread_mutex_init(&mutex->lock, &mutexattr);
 
36
    pthread_mutexattr_destroy(&mutexattr);
 
37
    if (err)
 
38
        error_exit(err, __func__);
 
39
}
 
40
 
 
41
void qemu_mutex_destroy(QemuMutex *mutex)
 
42
{
 
43
    int err;
 
44
 
 
45
    err = pthread_mutex_destroy(&mutex->lock);
 
46
    if (err)
 
47
        error_exit(err, __func__);
 
48
}
 
49
 
 
50
void qemu_mutex_lock(QemuMutex *mutex)
 
51
{
 
52
    int err;
 
53
 
 
54
    err = pthread_mutex_lock(&mutex->lock);
 
55
    if (err)
 
56
        error_exit(err, __func__);
 
57
}
 
58
 
 
59
int qemu_mutex_trylock(QemuMutex *mutex)
 
60
{
 
61
    return pthread_mutex_trylock(&mutex->lock);
 
62
}
 
63
 
 
64
void qemu_mutex_unlock(QemuMutex *mutex)
 
65
{
 
66
    int err;
 
67
 
 
68
    err = pthread_mutex_unlock(&mutex->lock);
 
69
    if (err)
 
70
        error_exit(err, __func__);
 
71
}
 
72
 
 
73
void qemu_cond_init(QemuCond *cond)
 
74
{
 
75
    int err;
 
76
 
 
77
    err = pthread_cond_init(&cond->cond, NULL);
 
78
    if (err)
 
79
        error_exit(err, __func__);
 
80
}
 
81
 
 
82
void qemu_cond_destroy(QemuCond *cond)
 
83
{
 
84
    int err;
 
85
 
 
86
    err = pthread_cond_destroy(&cond->cond);
 
87
    if (err)
 
88
        error_exit(err, __func__);
 
89
}
 
90
 
 
91
void qemu_cond_signal(QemuCond *cond)
 
92
{
 
93
    int err;
 
94
 
 
95
    err = pthread_cond_signal(&cond->cond);
 
96
    if (err)
 
97
        error_exit(err, __func__);
 
98
}
 
99
 
 
100
void qemu_cond_broadcast(QemuCond *cond)
 
101
{
 
102
    int err;
 
103
 
 
104
    err = pthread_cond_broadcast(&cond->cond);
 
105
    if (err)
 
106
        error_exit(err, __func__);
 
107
}
 
108
 
 
109
void qemu_cond_wait(QemuCond *cond, QemuMutex *mutex)
 
110
{
 
111
    int err;
 
112
 
 
113
    err = pthread_cond_wait(&cond->cond, &mutex->lock);
 
114
    if (err)
 
115
        error_exit(err, __func__);
 
116
}
 
117
 
 
118
void qemu_thread_create(QemuThread *thread,
 
119
                       void *(*start_routine)(void*),
 
120
                       void *arg)
 
121
{
 
122
    int err;
 
123
 
 
124
    /* Leave signal handling to the iothread.  */
 
125
    sigset_t set, oldset;
 
126
 
 
127
    sigfillset(&set);
 
128
    pthread_sigmask(SIG_SETMASK, &set, &oldset);
 
129
    err = pthread_create(&thread->thread, NULL, start_routine, arg);
 
130
    if (err)
 
131
        error_exit(err, __func__);
 
132
 
 
133
    pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 
134
}
 
135
 
 
136
void qemu_thread_get_self(QemuThread *thread)
 
137
{
 
138
    thread->thread = pthread_self();
 
139
}
 
140
 
 
141
int qemu_thread_is_self(QemuThread *thread)
 
142
{
 
143
   return pthread_equal(pthread_self(), thread->thread);
 
144
}
 
145
 
 
146
void qemu_thread_exit(void *retval)
 
147
{
 
148
    pthread_exit(retval);
 
149
}