From owner-svn-soc-all@FreeBSD.ORG Sat Aug 11 05:18:54 2012 Return-Path: Delivered-To: svn-soc-all@FreeBSD.org Received: from socsvn.FreeBSD.org (unknown [IPv6:2001:4f8:fff6::2f]) by hub.freebsd.org (Postfix) with SMTP id E5293106566B for ; Sat, 11 Aug 2012 05:18:51 +0000 (UTC) (envelope-from gmiller@FreeBSD.org) Received: by socsvn.FreeBSD.org (sSMTP sendmail emulation); Sat, 11 Aug 2012 05:18:51 +0000 Date: Sat, 11 Aug 2012 05:18:51 +0000 From: gmiller@FreeBSD.org To: svn-soc-all@FreeBSD.org MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Message-Id: <20120811051851.E5293106566B@hub.freebsd.org> Cc: Subject: socsvn commit: r240265 - in soc2012/gmiller/locking-head: . include lib/libwitness tools/regression/lib/libwitness X-BeenThere: svn-soc-all@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: SVN commit messages for the entire Summer of Code repository List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Sat, 11 Aug 2012 05:18:54 -0000 Author: gmiller Date: Sat Aug 11 05:18:51 2012 New Revision: 240265 URL: http://svnweb.FreeBSD.org/socsvn/?view=rev&rev=240265 Log: r240330@FreeBSD-dev: root | 2012-08-11 00:17:01 -0500 Treat locks that have the same name as the same lock. Modified: soc2012/gmiller/locking-head/ (props changed) soc2012/gmiller/locking-head/include/pthread_np.h soc2012/gmiller/locking-head/lib/libwitness/lists.c soc2012/gmiller/locking-head/lib/libwitness/lockinfo.c soc2012/gmiller/locking-head/lib/libwitness/logs.c soc2012/gmiller/locking-head/lib/libwitness/witness.h soc2012/gmiller/locking-head/lib/libwitness/wrappers.c soc2012/gmiller/locking-head/lib/libwitness/xml.c soc2012/gmiller/locking-head/tools/regression/lib/libwitness/graph.c soc2012/gmiller/locking-head/tools/regression/lib/libwitness/setname.c soc2012/gmiller/locking-head/tools/regression/lib/libwitness/shared.c Modified: soc2012/gmiller/locking-head/include/pthread_np.h ============================================================================== --- soc2012/gmiller/locking-head/include/pthread_np.h Sat Aug 11 05:18:33 2012 (r240264) +++ soc2012/gmiller/locking-head/include/pthread_np.h Sat Aug 11 05:18:51 2012 (r240265) @@ -62,20 +62,17 @@ struct pthread_lor_np { struct _pthread_lor_private *_pvt; - void *lock_first; - void *lock_second; - const char *name_first; - const char *name_second; + char *name_first; + char *name_second; }; struct _pthread_lockorder_private; struct pthread_lockorder_np { struct _pthread_lockorder_private *_pvt; - void *lock; char *name; - void *child; - void *sibling; + char *child; + char *sibling; }; typedef void (*pthread_switch_routine_t)(pthread_t, pthread_t); Modified: soc2012/gmiller/locking-head/lib/libwitness/lists.c ============================================================================== --- soc2012/gmiller/locking-head/lib/libwitness/lists.c Sat Aug 11 05:18:33 2012 (r240264) +++ soc2012/gmiller/locking-head/lib/libwitness/lists.c Sat Aug 11 05:18:51 2012 (r240265) @@ -40,10 +40,12 @@ static int exit_set = 0; void -add_lock(struct lock_info *lock) +add_lock(void *lock) { struct lock_entry *entry; struct lock_entry *next; + struct lock_instance *inst; + struct lock_info *info; if (exit_set == 0) { atexit(write_xml); @@ -54,6 +56,9 @@ return; } + inst = lookup_lock(lock); + info = get_lock_info(inst); + next = SLIST_FIRST(&lock_head); entry = malloc(sizeof(*entry)); @@ -61,7 +66,7 @@ return; } - entry->lock = lock; + entry->lock = info; if (reset_count > thread_reset_count) { thread_reset_count = reset_count; @@ -85,13 +90,18 @@ } void -remove_lock(struct lock_info *lock) +remove_lock(void *lock) { + struct lock_instance *inst; + struct lock_info *info; struct lock_entry *entry; struct lock_entry *temp; + inst = lookup_lock(lock); + info = get_lock_info(inst); + SLIST_FOREACH_SAFE(entry, &lock_head, lock_next, temp) { - if (entry->lock == lock) { + if (entry->lock == info) { SLIST_REMOVE(&lock_head, entry, lock_entry, lock_next); free(entry); Modified: soc2012/gmiller/locking-head/lib/libwitness/lockinfo.c ============================================================================== --- soc2012/gmiller/locking-head/lib/libwitness/lockinfo.c Sat Aug 11 05:18:33 2012 (r240264) +++ soc2012/gmiller/locking-head/lib/libwitness/lockinfo.c Sat Aug 11 05:18:51 2012 (r240265) @@ -32,46 +32,50 @@ static SLIST_HEAD(lock_info_head, lock_info) lock_info_head = SLIST_HEAD_INITIALIZER(lock_info_head); +static SLIST_HEAD(lock_instance_head, lock_instance) lock_instance_head = + SLIST_HEAD_INITIALIZER(lock_instance_head); + struct _pthread_lockorder_private { struct lock_info *last_record; }; -struct lock_info * +struct lock_instance * lookup_lock(void *lock) { - struct lock_info *info = NULL; + struct lock_instance *inst = NULL; + struct lock_instance *iter; - SLIST_FOREACH(info, &lock_info_head, lock_info_next) { - if (info->lock == lock && info->active) { + SLIST_FOREACH(iter, &lock_instance_head, lock_instance_next) { + if (iter->lock == lock) { + inst = iter; break; } } - if (info == NULL) { - info = malloc(sizeof(struct lock_info)); - if (info != NULL) { - info->active = 1; - info->lock = lock; - info->child = NULL; - info->sibling = NULL; - info->name = NULL; - SLIST_INIT(&info->bless_head); - SLIST_INSERT_HEAD(&lock_info_head, info, - lock_info_next); + if (inst == NULL) { + inst = malloc(sizeof(struct lock_instance)); + if (inst != NULL) { + inst->lock = lock; + inst->info = NULL; + + SLIST_INSERT_HEAD(&lock_instance_head, inst, + lock_instance_next); } } - return (info); + return (inst); } void destroy_lock(void *lock) { - struct lock_info *info; + struct lock_instance *inst; - info = lookup_lock(lock); - if (info != NULL) { - info->active = 0; + inst = lookup_lock(lock); + if (inst != NULL) { + SLIST_REMOVE(&lock_instance_head, inst, lock_instance, + lock_instance_next); + free(inst); } } @@ -114,36 +118,122 @@ } } -int -pthread_setname_np(void *lock, const char *name) +void +reset_lock_instance(void) +{ + struct lock_instance *inst; + + while (!SLIST_EMPTY(&lock_instance_head)) { + inst = SLIST_FIRST(&lock_instance_head); + + SLIST_REMOVE_HEAD(&lock_instance_head, lock_instance_next); + + free(inst); + } +} + +struct lock_info * +get_lock_info(struct lock_instance *inst) { struct lock_info *info; - info = lookup_lock(lock); + if (inst == NULL) { + return (NULL); + } + + if (inst->info != NULL) { + return (inst->info); + } + + info = malloc(sizeof(struct lock_info)); + if (info != NULL) { + info->name = NULL; + info->child = NULL; + info->sibling = NULL; + SLIST_INIT(&info->bless_head); + SLIST_INSERT_HEAD(&lock_info_head, info, lock_info_next); + + inst->info = info; + } + + return (info); +} + +static struct lock_info * +lookup_info(const char *name) +{ + struct lock_info *info = NULL; + struct lock_info *iter; + + SLIST_FOREACH(iter, &lock_info_head, lock_info_next) { + if (strcmp(name, get_lock_name(iter)) == 0) { + info = iter; + break; + } + } + if (info == NULL) { - return (ENOMEM); + info = malloc(sizeof(struct lock_info)); + if (info != NULL) { + info->name = strdup(name); + info->child = NULL; + info->sibling = NULL; + SLIST_INIT(&info->bless_head); + SLIST_INSERT_HEAD(&lock_info_head, info, + lock_info_next); + } } - info->name = reallocf(info->name, strlen(name) + 1); - if (info->name == NULL) { - return (errno); + return (info); +} + +int +pthread_setname_np(void *lock, const char *name) +{ + struct lock_instance *inst; + + inst = lookup_lock(lock); + if (inst == NULL) { + return (ENOMEM); } - strcpy(info->name, name); + inst->info = lookup_info(name); + if (inst->info == NULL) { + return (ENOMEM); + } return (0); } +const char * +get_lock_name(struct lock_info *info) +{ + if (info->name != NULL) { + return (info->name); + } + + return ""; +} + void -check_default_name(struct lock_info *lock, const char *prefix) +check_default_name(void *lock, const char *prefix) { - if (lock != NULL && lock->name == NULL) { - lock->name = malloc(MAX_DEFAULT_NAME_LENGTH + 1); - if (lock->name != NULL) { - snprintf(lock->name, MAX_DEFAULT_NAME_LENGTH, "%s%p", - prefix, lock->lock); - } + struct lock_instance *inst; + struct lock_info *info; + + inst = lookup_lock(lock); + info = get_lock_info(inst); + + if (info == NULL || info->name != NULL) { + return; + } + + info->name = malloc(MAX_DEFAULT_NAME_LENGTH + 1); + if (info->name == NULL) { + return; } + + snprintf(info->name, MAX_DEFAULT_NAME_LENGTH, "%s_%p", prefix, lock); } int @@ -196,20 +286,18 @@ if (node->name != NULL) { free(node->name); - node->name = NULL; } - node->lock = node->_pvt->last_record->lock; - if (node->_pvt->last_record->name != NULL) { - node->name = strdup(node->_pvt->last_record->name); - } + node->name = strdup(get_lock_name(node->_pvt->last_record)); if (node->_pvt->last_record->child != NULL) { - node->child = node->_pvt->last_record->child->lock; + node->child = + strdup(get_lock_name(node->_pvt->last_record->child)); } else { node->child = NULL; } if (node->_pvt->last_record->sibling != NULL) { - node->sibling = node->_pvt->last_record->sibling->lock; + node->sibling = + strdup(get_lock_name(node->_pvt->last_record->sibling)); } else { node->sibling = NULL; } @@ -222,11 +310,13 @@ void pthread_lockorder_end_np(struct pthread_lockorder_np *node) { - free(node->_pvt); - node->_pvt = NULL; + if (node->_pvt != NULL) { + free(node->_pvt); + node->_pvt = NULL; + } if (node->name != NULL) { - free((char *)node->name); + free(node->name); node->name = NULL; } } Modified: soc2012/gmiller/locking-head/lib/libwitness/logs.c ============================================================================== --- soc2012/gmiller/locking-head/lib/libwitness/logs.c Sat Aug 11 05:18:33 2012 (r240264) +++ soc2012/gmiller/locking-head/lib/libwitness/logs.c Sat Aug 11 05:18:51 2012 (r240265) @@ -57,6 +57,7 @@ pthread_lor_begin_np(struct pthread_lor_np *lor) { int ret = 0; + /* The lock isn't needed to prevent races, but it is needed to ensure that any locks grabbed by malloc() don't get logged. @@ -70,6 +71,9 @@ lor->_pvt->last_record = NULL; } + lor->name_first = NULL; + lor->name_second = NULL; + pthread_mutex_unlock(&witness_mtx); return (ret); @@ -90,10 +94,10 @@ } if (lor->_pvt->last_record != NULL) { - lor->lock_first = lor->_pvt->last_record->lock_first->lock; - lor->lock_second = lor->_pvt->last_record->lock_second->lock; - lor->name_first = lor->_pvt->last_record->lock_first->name; - lor->name_second = lor->_pvt->last_record->lock_second->name; + lor->name_first = + strdup(get_lock_name(lor->_pvt->last_record->lock_first)); + lor->name_second = + strdup(get_lock_name(lor->_pvt->last_record->lock_second)); res = 1; } @@ -110,6 +114,14 @@ free(lor->_pvt); lor->_pvt = NULL; } + + if (lor->name_first != NULL) { + free(lor->name_first); + } + + if (lor->name_second != NULL) { + free(lor->name_second); + } } void Modified: soc2012/gmiller/locking-head/lib/libwitness/witness.h ============================================================================== --- soc2012/gmiller/locking-head/lib/libwitness/witness.h Sat Aug 11 05:18:33 2012 (r240264) +++ soc2012/gmiller/locking-head/lib/libwitness/witness.h Sat Aug 11 05:18:51 2012 (r240265) @@ -41,31 +41,38 @@ struct lock_info { SLIST_ENTRY(lock_info) lock_info_next; - SLIST_ENTRY(lock_info) root_next; - void *lock; - int active; struct lock_info *child; struct lock_info *sibling; SLIST_HEAD(bless_head, blessing) bless_head; char *name; }; +struct lock_instance { + SLIST_ENTRY(lock_instance) lock_instance_next; + struct lock_info *info; + void *lock; +}; + extern pthread_mutex_t witness_mtx; -void add_lock(struct lock_info *lock); -void remove_lock(struct lock_info *lock); -int insert_lock(struct lock_info *new_lock, - struct lock_info *previous); +void add_lock(void *lock); +void remove_lock(void *lock); + +int insert_lock(struct lock_info *from, + struct lock_info *to); void reset_lists(void); void log_reversal(struct lock_info *lock, struct lock_info *previous); -struct lock_info *lookup_lock(void *lock); -void destroy_lock(void *lock); int blessed(struct lock_info *first, struct lock_info *second); void reset_lock_info(void); -void check_default_name(struct lock_info *lock, const char *prefix); +void check_default_name(void *lock, const char *prefix); +const char *get_lock_name(struct lock_info *info); +struct lock_info *get_lock_info(struct lock_instance *lock); +void destroy_lock(void *lock); +struct lock_instance *lookup_lock(void *lock); +void reset_lock_instance(void); void write_xml(void); Modified: soc2012/gmiller/locking-head/lib/libwitness/wrappers.c ============================================================================== --- soc2012/gmiller/locking-head/lib/libwitness/wrappers.c Sat Aug 11 05:18:33 2012 (r240264) +++ soc2012/gmiller/locking-head/lib/libwitness/wrappers.c Sat Aug 11 05:18:51 2012 (r240265) @@ -54,16 +54,14 @@ pthread_mutex_lock(pthread_mutex_t *mutex) { int ret; - struct lock_info *lock; _pthread_mutex_lock(&witness_mtx); - lock = lookup_lock(mutex); - check_default_name(lock, "mutex_"); + check_default_name(mutex, "mutex"); ret = _pthread_mutex_lock(mutex); if (mutex != &witness_mtx && ret == 0) { - add_lock(lock); + add_lock(mutex); } _pthread_mutex_unlock(&witness_mtx); @@ -75,16 +73,14 @@ pthread_mutex_trylock(pthread_mutex_t *mutex) { int ret; - struct lock_info *lock; _pthread_mutex_lock(&witness_mtx); - lock = lookup_lock(mutex); - check_default_name(lock, "mutex_"); + check_default_name(mutex, "mutex"); ret = _pthread_mutex_trylock(mutex); if (mutex != &witness_mtx && ret == 0) { - add_lock(lock); + add_lock(mutex); } _pthread_mutex_unlock(&witness_mtx); @@ -96,16 +92,14 @@ pthread_mutex_timedlock(pthread_mutex_t *mutex, const struct timespec *ts) { int ret; - struct lock_info *lock; _pthread_mutex_lock(&witness_mtx); - lock = lookup_lock(mutex); - check_default_name(lock, "mutex_"); + check_default_name(mutex, "mutex"); ret = _pthread_mutex_timedlock(mutex, ts); if (mutex != &witness_mtx && ret == 0) { - add_lock(lock); + add_lock(mutex); } _pthread_mutex_unlock(&witness_mtx); @@ -122,7 +116,7 @@ ret = _pthread_mutex_unlock(mutex); if (mutex != &witness_mtx && ret == 0) { - remove_lock(lookup_lock(mutex)); + remove_lock(mutex); } _pthread_mutex_unlock(&witness_mtx); @@ -149,16 +143,14 @@ pthread_rwlock_rdlock(pthread_rwlock_t *rwlock) { int ret; - struct lock_info *lock; _pthread_mutex_lock(&witness_mtx); - lock = lookup_lock(rwlock); - check_default_name(lock, "rwlock_"); + check_default_name(rwlock, "rwlock"); ret = _pthread_rwlock_rdlock(rwlock); if (ret == 0) { - add_lock(lock); + add_lock(rwlock); } _pthread_mutex_unlock(&witness_mtx); @@ -170,16 +162,14 @@ pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock) { int ret; - struct lock_info *lock; _pthread_mutex_lock(&witness_mtx); - lock = lookup_lock(rwlock); - check_default_name(lock, "rwlock_"); + check_default_name(rwlock, "rwlock"); ret = _pthread_rwlock_tryrdlock(rwlock); if (ret == 0) { - add_lock(lock); + add_lock(rwlock); } _pthread_mutex_unlock(&witness_mtx); @@ -191,16 +181,14 @@ pthread_rwlock_timedrdlock(pthread_rwlock_t *rwlock, const struct timespec *ts) { int ret; - struct lock_info *lock; _pthread_mutex_lock(&witness_mtx); - lock = lookup_lock(rwlock); - check_default_name(lock, "rwlock_"); + check_default_name(rwlock, "rwlock"); ret = _pthread_rwlock_timedrdlock(rwlock, ts); if (ret == 0) { - add_lock(lock); + add_lock(rwlock); } _pthread_mutex_unlock(&witness_mtx); @@ -212,16 +200,14 @@ pthread_rwlock_wrlock(pthread_rwlock_t *rwlock) { int ret; - struct lock_info *lock; _pthread_mutex_lock(&witness_mtx); - lock = lookup_lock(rwlock); - check_default_name(lock, "rwlock_"); + check_default_name(rwlock, "rwlock"); ret = _pthread_rwlock_wrlock(rwlock); if (ret == 0) { - add_lock(lock); + add_lock(rwlock); } _pthread_mutex_unlock(&witness_mtx); @@ -233,16 +219,14 @@ pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock) { int ret; - struct lock_info *lock; _pthread_mutex_lock(&witness_mtx); - lock = lookup_lock(rwlock); - check_default_name(lock, "rwlock_"); + check_default_name(rwlock, "rwlock"); ret = _pthread_rwlock_trywrlock(rwlock); if (ret == 0) { - add_lock(lock); + add_lock(rwlock); } _pthread_mutex_unlock(&witness_mtx); @@ -254,16 +238,14 @@ pthread_rwlock_timedwrlock(pthread_rwlock_t *rwlock, const struct timespec *ts) { int ret; - struct lock_info *lock; _pthread_mutex_lock(&witness_mtx); - lock = lookup_lock(rwlock); - check_default_name(lock, "rwlock_"); + check_default_name(rwlock, "rwlock"); ret = _pthread_rwlock_timedwrlock(rwlock, ts); if (ret == 0) { - add_lock(lock); + add_lock(rwlock); } _pthread_mutex_unlock(&witness_mtx); @@ -280,7 +262,7 @@ ret = _pthread_rwlock_unlock(rwlock); if (ret == 0) { - remove_lock(lookup_lock(rwlock)); + remove_lock(rwlock); } _pthread_mutex_unlock(&witness_mtx); @@ -307,16 +289,14 @@ pthread_spin_lock(pthread_spinlock_t *spin) { int ret; - struct lock_info *lock; _pthread_mutex_lock(&witness_mtx); - lock = lookup_lock(spin); - check_default_name(lock, "spinlock_"); + check_default_name(spin, "spinlock"); ret = _pthread_spin_lock(spin); if (ret == 0) { - add_lock(lock); + add_lock(spin); } _pthread_mutex_unlock(&witness_mtx); @@ -328,16 +308,14 @@ pthread_spin_trylock(pthread_spinlock_t *spin) { int ret; - struct lock_info *lock; _pthread_mutex_lock(&witness_mtx); - lock = lookup_lock(spin); - check_default_name(lock, "spinlock_"); + check_default_name(spin, "spinlock"); ret = _pthread_spin_lock(spin); if (ret == 0) { - add_lock(lock); + add_lock(spin); } _pthread_mutex_unlock(&witness_mtx); @@ -354,7 +332,7 @@ ret = _pthread_spin_unlock(spin); if (ret == 0) { - remove_lock(lookup_lock(spin)); + remove_lock(spin); } _pthread_mutex_unlock(&witness_mtx); @@ -384,7 +362,8 @@ _pthread_mutex_lock(&witness_mtx); - if (insert_lock(lookup_lock(first), lookup_lock(second)) < 0) { + if (insert_lock(get_lock_info(lookup_lock(first)), + get_lock_info(lookup_lock(second))) < 0) { ret = EINVAL; } @@ -398,14 +377,19 @@ { struct lock_info *first; struct lock_info *second; + struct lock_instance *first_inst; + struct lock_instance *second_inst; struct blessing *first_bless = NULL; struct blessing *second_bless = NULL; int ret = 0; _pthread_mutex_lock(&witness_mtx); - first = lookup_lock(first_addr); - second = lookup_lock(second_addr); + first_inst = lookup_lock(first_addr); + second_inst = lookup_lock(second_addr); + + first = get_lock_info(first_inst); + second = get_lock_info(second_inst); first_bless = malloc(sizeof(struct blessing)); second_bless = malloc(sizeof(struct blessing)); @@ -414,14 +398,6 @@ second_bless == NULL) { ret = ENOMEM; - if (first != NULL) { - free(first); - } - - if (second != NULL) { - free(second); - } - if (first_bless != NULL) { free(first_bless); } @@ -445,6 +421,7 @@ _pthread_mutex_lock(&witness_mtx); reset_lists(); + reset_lock_instance(); reset_lock_info(); _pthread_mutex_unlock(&witness_mtx); Modified: soc2012/gmiller/locking-head/lib/libwitness/xml.c ============================================================================== --- soc2012/gmiller/locking-head/lib/libwitness/xml.c Sat Aug 11 05:18:33 2012 (r240264) +++ soc2012/gmiller/locking-head/lib/libwitness/xml.c Sat Aug 11 05:18:51 2012 (r240265) @@ -68,13 +68,6 @@ fprintf(xml_file, "<%s>%s\n", tag, str, tag); } -static void -write_element_pointer(const char *tag, void *ptr) -{ - indent(); - fprintf(xml_file, "<%s>%p\n", tag, ptr, tag); -} - void write_xml(void) { @@ -91,15 +84,8 @@ while (pthread_lor_next_np(&lor)) { open_element("lor"); - open_element("first"); - write_element_pointer("address", lor.lock_first); - write_element_string("name", lor.name_first); - close_element("first"); - - open_element("second"); - write_element_pointer("address", lor.lock_second); - write_element_string("name", lor.name_second); - close_element("second"); + write_element_string("first", lor.name_first); + write_element_string("second", lor.name_second); close_element("lor"); } @@ -113,13 +99,12 @@ while (pthread_lockorder_next_np(&node)) { open_element("node"); - write_element_pointer("address", node.lock); write_element_string("name", node.name); if (node.child != NULL) { - write_element_pointer("child", node.child); + write_element_string("child", node.child); } if (node.sibling != NULL) { - write_element_pointer("sibling", node.sibling); + write_element_string("sibling", node.sibling); } close_element("node"); Modified: soc2012/gmiller/locking-head/tools/regression/lib/libwitness/graph.c ============================================================================== --- soc2012/gmiller/locking-head/tools/regression/lib/libwitness/graph.c Sat Aug 11 05:18:33 2012 (r240264) +++ soc2012/gmiller/locking-head/tools/regression/lib/libwitness/graph.c Sat Aug 11 05:18:51 2012 (r240265) @@ -27,23 +27,25 @@ #include #include +#include #include #include "check.h" void -check_graph(pthread_mutex_t *lock_buffer, int lock_count) +check_graph(int lock_count) { struct pthread_lockorder_np order; int i; pthread_lockorder_begin_np(&order); while (pthread_lockorder_next_np(&order)) { - i = (pthread_mutex_t *)order.lock - lock_buffer; - if (i >= 0 && i < lock_count) { - check((i < (lock_count - 1) && - (lock_buffer + i + 1) == order.child) || - (i == (lock_count - 1) && order.child == NULL)); + i = atol(order.name); + if (i >= 1 && i <= lock_count) { + check((i < lock_count && + order.child != NULL && + atol(order.child) == i + 1) || + (i == lock_count && order.child == NULL)); check(order.sibling == NULL); } } @@ -87,6 +89,7 @@ int i; pthread_mutex_t *lock_buffer; int *lock_set; + char name[11]; pthread_lockorder_reset_np(); @@ -95,10 +98,13 @@ for (i = 0; i < lock_count; i++) { pthread_mutex_init(&lock_buffer[i], NULL); + + sprintf(name, "%d", i + 1); + pthread_setname_np(&lock_buffer[i], name); } graph_test(lock_buffer, lock_count, lock_set, 0, 0); - check_graph(lock_buffer, lock_count); + check_graph(lock_count); for (i = 0; i < lock_count; i++) { pthread_mutex_destroy(&lock_buffer[i]); Modified: soc2012/gmiller/locking-head/tools/regression/lib/libwitness/setname.c ============================================================================== --- soc2012/gmiller/locking-head/tools/regression/lib/libwitness/setname.c Sat Aug 11 05:18:33 2012 (r240264) +++ soc2012/gmiller/locking-head/tools/regression/lib/libwitness/setname.c Sat Aug 11 05:18:51 2012 (r240265) @@ -61,16 +61,16 @@ pthread_lor_begin_np(&lor); while (pthread_lor_next_np(&lor)) { + check((strcmp(lor.name_first, "mutex 1") == 0 && + strcmp(lor.name_second, "mutex 2") == 0) || + (strcmp(lor.name_first, "mutex 2") == 0 && + strcmp(lor.name_second, "mutex 1") == 0)); + record_count++; } pthread_lor_end_np(&lor); check(record_count == 1); - - check((strcmp(lor.name_first, "mutex 1") == 0 && - strcmp(lor.name_second, "mutex 2") == 0) || - (strcmp(lor.name_first, "mutex 2") == 0 && - strcmp(lor.name_second, "mutex 1") == 0)); } int Modified: soc2012/gmiller/locking-head/tools/regression/lib/libwitness/shared.c ============================================================================== --- soc2012/gmiller/locking-head/tools/regression/lib/libwitness/shared.c Sat Aug 11 05:18:33 2012 (r240264) +++ soc2012/gmiller/locking-head/tools/regression/lib/libwitness/shared.c Sat Aug 11 05:18:51 2012 (r240265) @@ -31,41 +31,89 @@ #include "check.h" void -share_test(void) +unshared_test(void) { pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER; - pthread_setname_np(mutex1, "shared_mutex"); - pthread_setname_np(mutex2, "shared_mutex"); + pthread_mutex_lock(&mutex1); + pthread_mutex_lock(&mutex2); + + pthread_mutex_unlock(&mutex2); + pthread_mutex_unlock(&mutex1); + + pthread_mutex_lock(&mutex2); + pthread_mutex_lock(&mutex1); + + pthread_mutex_unlock(&mutex1); + pthread_mutex_unlock(&mutex2); + + pthread_mutex_destroy(&mutex1); + pthread_mutex_destroy(&mutex2); +} + +void +check_unshared(void) +{ + struct pthread_lor_np lor; + int lor_count = 0; + + pthread_lor_begin_np(&lor); + while (pthread_lor_next_np(&lor)) { + lor_count++; + } + pthread_lor_end_np(&lor); + + check(lor_count == 1); +} + +void +shared_test(void) +{ + pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER; + pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER; + + pthread_lor_clear_np(); + + pthread_setname_np(&mutex1, "shared_mutex"); + pthread_setname_np(&mutex2, "shared_mutex"); pthread_mutex_lock(&mutex1); pthread_mutex_lock(&mutex2); pthread_mutex_unlock(&mutex2); pthread_mutex_unlock(&mutex1); + + pthread_mutex_lock(&mutex2); + pthread_mutex_lock(&mutex1); + + pthread_mutex_unlock(&mutex1); + pthread_mutex_unlock(&mutex2); } void -check_share(void) +check_shared(void) { - struct pthread_lockorder_np order; - int node_count = 0; + struct pthread_lor_np lor; + int lor_count = 0; - pthread_lockorder_begin_np(&order); - while (pthread_lockorder_next_np(&order)) { - node_count++; + pthread_lor_begin_np(&lor); + while (pthread_lor_next_np(&lor)) { + lor_count++; } - pthread_lockorder_end_np(&order); + pthread_lor_end_np(&lor); - check(node_count == 0); + check(lor_count == 0); } int main(void) { - share_test(); - check_share(); + unshared_test(); + check_unshared(); + + shared_test(); + check_shared(); show_test_results();