[libvirt] [PATCH V2 1/3] rename arguments of virthread functions

Jincheng Miao jmiao at redhat.com
Mon Jul 21 10:13:35 UTC 2014


For keeping consistence of other functions in virthread.c,
rename arguments 'm', 'c' to 'mutex', 'rwlock' and 'cond'.

Signed-off-by: Jincheng Miao <jmiao at redhat.com>
---
 src/util/virthread.c | 65 ++++++++++++++++++++++++++--------------------------
 src/util/virthread.h | 33 +++++++++++++-------------
 2 files changed, 50 insertions(+), 48 deletions(-)

diff --git a/src/util/virthread.c b/src/util/virthread.c
index 7e841d1..e22cadd 100644
--- a/src/util/virthread.c
+++ b/src/util/virthread.c
@@ -48,13 +48,13 @@ int virOnce(virOnceControlPtr once, virOnceFunc init)
 }
 
 
-int virMutexInit(virMutexPtr m)
+int virMutexInit(virMutexPtr mutex)
 {
     int ret;
     pthread_mutexattr_t attr;
     pthread_mutexattr_init(&attr);
     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
-    ret = pthread_mutex_init(&m->lock, &attr);
+    ret = pthread_mutex_init(&mutex->lock, &attr);
     pthread_mutexattr_destroy(&attr);
     if (ret != 0) {
         errno = ret;
@@ -63,13 +63,13 @@ int virMutexInit(virMutexPtr m)
     return 0;
 }
 
-int virMutexInitRecursive(virMutexPtr m)
+int virMutexInitRecursive(virMutexPtr mutex)
 {
     int ret;
     pthread_mutexattr_t attr;
     pthread_mutexattr_init(&attr);
     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
-    ret = pthread_mutex_init(&m->lock, &attr);
+    ret = pthread_mutex_init(&mutex->lock, &attr);
     pthread_mutexattr_destroy(&attr);
     if (ret != 0) {
         errno = ret;
@@ -78,26 +78,26 @@ int virMutexInitRecursive(virMutexPtr m)
     return 0;
 }
 
-void virMutexDestroy(virMutexPtr m)
+void virMutexDestroy(virMutexPtr mutex)
 {
-    pthread_mutex_destroy(&m->lock);
+    pthread_mutex_destroy(&mutex->lock);
 }
 
-void virMutexLock(virMutexPtr m)
+void virMutexLock(virMutexPtr mutex)
 {
-    pthread_mutex_lock(&m->lock);
+    pthread_mutex_lock(&mutex->lock);
 }
 
-void virMutexUnlock(virMutexPtr m)
+void virMutexUnlock(virMutexPtr mutex)
 {
-    pthread_mutex_unlock(&m->lock);
+    pthread_mutex_unlock(&mutex->lock);
 }
 
 
-int virRWLockInit(virRWLockPtr m)
+int virRWLockInit(virRWLockPtr rwlock)
 {
     int ret;
-    ret = pthread_rwlock_init(&m->lock, NULL);
+    ret = pthread_rwlock_init(&rwlock->lock, NULL);
     if (ret != 0) {
         errno = ret;
         return -1;
@@ -105,59 +105,60 @@ int virRWLockInit(virRWLockPtr m)
     return 0;
 }
 
-void virRWLockDestroy(virRWLockPtr m)
+void virRWLockDestroy(virRWLockPtr rwlock)
 {
-    pthread_rwlock_destroy(&m->lock);
+    pthread_rwlock_destroy(&rwlock->lock);
 }
 
 
-void virRWLockRead(virRWLockPtr m)
+void virRWLockRead(virRWLockPtr rwlock)
 {
-    pthread_rwlock_rdlock(&m->lock);
+    pthread_rwlock_rdlock(&rwlock->lock);
 }
 
-void virRWLockWrite(virRWLockPtr m)
+void virRWLockWrite(virRWLockPtr rwlock)
 {
-    pthread_rwlock_wrlock(&m->lock);
+    pthread_rwlock_wrlock(&rwlock->lock);
 }
 
 
-void virRWLockUnlock(virRWLockPtr m)
+void virRWLockUnlock(virRWLockPtr rwlock)
 {
-    pthread_rwlock_unlock(&m->lock);
+    pthread_rwlock_unlock(&rwlock->lock);
 }
 
-int virCondInit(virCondPtr c)
+int virCondInit(virCondPtr cond)
 {
     int ret;
-    if ((ret = pthread_cond_init(&c->cond, NULL)) != 0) {
+    if ((ret = pthread_cond_init(&cond->cond, NULL)) != 0) {
         errno = ret;
         return -1;
     }
     return 0;
 }
 
-int virCondDestroy(virCondPtr c)
+int virCondDestroy(virCondPtr cond)
 {
     int ret;
-    if ((ret = pthread_cond_destroy(&c->cond)) != 0) {
+    if ((ret = pthread_cond_destroy(&cond->cond)) != 0) {
         errno = ret;
         return -1;
     }
     return 0;
 }
 
-int virCondWait(virCondPtr c, virMutexPtr m)
+int virCondWait(virCondPtr cond, virMutexPtr mutex)
 {
     int ret;
-    if ((ret = pthread_cond_wait(&c->cond, &m->lock)) != 0) {
+    if ((ret = pthread_cond_wait(&cond->cond, &mutex->lock)) != 0) {
         errno = ret;
         return -1;
     }
     return 0;
 }
 
-int virCondWaitUntil(virCondPtr c, virMutexPtr m, unsigned long long whenms)
+int virCondWaitUntil(virCondPtr cond, virMutexPtr mutex,
+                     unsigned long long whenms)
 {
     int ret;
     struct timespec ts;
@@ -165,21 +166,21 @@ int virCondWaitUntil(virCondPtr c, virMutexPtr m, unsigned long long whenms)
     ts.tv_sec = whenms / 1000;
     ts.tv_nsec = (whenms % 1000) * 1000;
 
-    if ((ret = pthread_cond_timedwait(&c->cond, &m->lock, &ts)) != 0) {
+    if ((ret = pthread_cond_timedwait(&cond->cond, &mutex->lock, &ts)) != 0) {
         errno = ret;
         return -1;
     }
     return 0;
 }
 
-void virCondSignal(virCondPtr c)
+void virCondSignal(virCondPtr cond)
 {
-    pthread_cond_signal(&c->cond);
+    pthread_cond_signal(&cond->cond);
 }
 
-void virCondBroadcast(virCondPtr c)
+void virCondBroadcast(virCondPtr cond)
 {
-    pthread_cond_broadcast(&c->cond);
+    pthread_cond_broadcast(&cond->cond);
 }
 
 struct virThreadArgs {
diff --git a/src/util/virthread.h b/src/util/virthread.h
index 4b92a43..7c71c6b 100644
--- a/src/util/virthread.h
+++ b/src/util/virthread.h
@@ -122,35 +122,36 @@ unsigned long long virThreadID(virThreadPtr thread);
 int virOnce(virOnceControlPtr once, virOnceFunc init)
     ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_RETURN_CHECK;
 
-int virMutexInit(virMutexPtr m) ATTRIBUTE_RETURN_CHECK;
-int virMutexInitRecursive(virMutexPtr m) ATTRIBUTE_RETURN_CHECK;
-void virMutexDestroy(virMutexPtr m);
+int virMutexInit(virMutexPtr mutex) ATTRIBUTE_RETURN_CHECK;
+int virMutexInitRecursive(virMutexPtr mutex) ATTRIBUTE_RETURN_CHECK;
+void virMutexDestroy(virMutexPtr mutex);
 
-void virMutexLock(virMutexPtr m);
-void virMutexUnlock(virMutexPtr m);
+void virMutexLock(virMutexPtr mutex);
+void virMutexUnlock(virMutexPtr mutex);
 
 
-int virRWLockInit(virRWLockPtr m) ATTRIBUTE_RETURN_CHECK;
-void virRWLockDestroy(virRWLockPtr m);
+int virRWLockInit(virRWLockPtr rwlock) ATTRIBUTE_RETURN_CHECK;
+void virRWLockDestroy(virRWLockPtr rwlock);
 
-void virRWLockRead(virRWLockPtr m);
-void virRWLockWrite(virRWLockPtr m);
-void virRWLockUnlock(virRWLockPtr m);
+void virRWLockRead(virRWLockPtr rwlock);
+void virRWLockWrite(virRWLockPtr rwlock);
+void virRWLockUnlock(virRWLockPtr rwlock);
 
 
-int virCondInit(virCondPtr c) ATTRIBUTE_RETURN_CHECK;
-int virCondDestroy(virCondPtr c);
+int virCondInit(virCondPtr cond) ATTRIBUTE_RETURN_CHECK;
+int virCondDestroy(virCondPtr cond);
 
 /* virCondWait, virCondWaitUntil:
  * These functions can return without the associated predicate
  * changing value. Therefore in nearly all cases they
  * should be enclosed in a while loop that checks the predicate.
  */
-int virCondWait(virCondPtr c, virMutexPtr m) ATTRIBUTE_RETURN_CHECK;
-int virCondWaitUntil(virCondPtr c, virMutexPtr m, unsigned long long whenms) ATTRIBUTE_RETURN_CHECK;
+int virCondWait(virCondPtr cond, virMutexPtr mutex) ATTRIBUTE_RETURN_CHECK;
+int virCondWaitUntil(virCondPtr cond, virMutexPtr mutex,
+                     unsigned long long whenms) ATTRIBUTE_RETURN_CHECK;
 
-void virCondSignal(virCondPtr c);
-void virCondBroadcast(virCondPtr c);
+void virCondSignal(virCondPtr cond);
+void virCondBroadcast(virCondPtr cond);
 
 
 typedef void (*virThreadLocalCleanup)(void *);
-- 
1.8.3.1




More information about the libvir-list mailing list