From: pschwan Date: Thu, 5 Dec 2002 08:42:29 +0000 (+0000) Subject: land b_md onto HEAD: X-Git-Tag: v1_7_100~4184 X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=commitdiff_plain;h=4b28597565a5e732e1bb2b6aecf25e71bfeacccc land b_md onto HEAD: - LRU counters were broken, causing constant lock purge (433, 432) - the first part of the fixes for the ldlm_handle2lock race (419) - cleanup unused ll_inode_info field (442) - keep ioctl semaphore from serializing test_getattr/brw --- diff --git a/lustre/ChangeLog b/lustre/ChangeLog index d9a55e5..45d39ab 100644 --- a/lustre/ChangeLog +++ b/lustre/ChangeLog @@ -1,4 +1,11 @@ -2002-01-02 Andreas Dilger +TBA + * bug fixes + - LRU counters were broken, causing constant lock purge (433, 432) + - garbage on read from stripes with failed OSTs (441) + - mark OSCs as active before reconnecting during recovery (438) + - lov_enqueue and lov_cancel need to handle inactive OSTs (403) + +2002-12-02 Andreas Dilger * version v0_5_18 * bug fixes - fix many simultaneous client startup (392) @@ -12,10 +19,10 @@ - fix echo client over LOV (409) - fix dbench 2, extN refcount problem (170, 258, 356, 418) - fix double-O_EXCL intent crash (424) - - fix LOV-with-dead-OST bugs (307, 325, 326, 400, 403, 410) - * Features + - avoid sending multiple lock CANCELs (352) + * Features - MDS can do multi-client recovery (modulo bugs in new code) - * Documentation + * Documentation - many updates, edits, cleanups 2002-11-18 Phil Schwan diff --git a/lustre/include/linux/lustre_dlm.h b/lustre/include/linux/lustre_dlm.h index 29a800e..916db86 100644 --- a/lustre/include/linux/lustre_dlm.h +++ b/lustre/include/linux/lustre_dlm.h @@ -42,19 +42,18 @@ typedef enum { #define LDLM_FL_CBPENDING (1 << 4) // this lock is being destroyed #define LDLM_FL_AST_SENT (1 << 5) // blocking or cancel packet was sent -#define LDLM_FL_DESTROYED (1 << 6) // this lock is destroyed -#define LDLM_FL_WAIT_NOREPROC (1 << 7)// not a real lock flag,not saved in lock -#define LDLM_FL_CANCEL (1 << 8) // cancellation callback already run +#define LDLM_FL_WAIT_NOREPROC (1 << 6)// not a real lock flag,not saved in lock +#define LDLM_FL_CANCEL (1 << 7) // cancellation callback already run /* Lock is being replayed. This could probably be implied by the fact that one * of BLOCK_{GRANTED,CONV,WAIT} is set, but that is pretty dangerous. */ -#define LDLM_FL_REPLAY (1 << 9) +#define LDLM_FL_REPLAY (1 << 8) -#define LDLM_FL_INTENT_ONLY (1 << 10) /* don't grant lock, just do intent */ -#define LDLM_FL_LOCAL_ONLY (1 << 11) /* see ldlm_cli_cancel_unused */ -#define LDLM_FL_NO_CALLBACK (1 << 12) /* see ldlm_cli_cancel_unused */ -#define LDLM_FL_HAS_INTENT (1 << 13) /* lock request has intent */ -#define LDLM_FL_CANCELING (1 << 14) /* lock cancel has already been sent */ +#define LDLM_FL_INTENT_ONLY (1 << 9) /* don't grant lock, just do intent */ +#define LDLM_FL_LOCAL_ONLY (1 << 10) /* see ldlm_cli_cancel_unused */ +#define LDLM_FL_NO_CALLBACK (1 << 11) /* see ldlm_cli_cancel_unused */ +#define LDLM_FL_HAS_INTENT (1 << 12) /* lock request has intent */ +#define LDLM_FL_CANCELING (1 << 13) /* lock cancel has already been sent */ /* The blocking callback is overloaded to perform two functions. These flags * indicate which operation should be performed. */ @@ -146,7 +145,7 @@ typedef int (*ldlm_completion_callback)(struct ldlm_lock *lock, int flags); struct ldlm_lock { __u64 l_random; - int l_refc; + atomic_t l_refc; struct ldlm_resource *l_resource; struct ldlm_lock *l_parent; struct list_head l_children; @@ -174,6 +173,7 @@ struct ldlm_lock { __u32 l_readers; __u32 l_writers; + __u8 l_destroyed; /* If the lock is granted, a process sleeps on this waitq to learn when * it's no longer in use. If the lock is not granted, a process sleeps @@ -326,6 +326,7 @@ struct ldlm_lock *__ldlm_handle2lock(struct lustre_handle *, int strict, int flags); void ldlm_cancel_callback(struct ldlm_lock *); int ldlm_lock_set_data(struct lustre_handle *, void *data, int datalen); +void ldlm_lock_remove_from_lru(struct ldlm_lock *); static inline struct ldlm_lock *ldlm_handle2lock(struct lustre_handle *h) { @@ -395,7 +396,7 @@ struct ldlm_resource *ldlm_resource_get(struct ldlm_namespace *ns, struct ldlm_resource *parent, __u64 *name, __u32 type, int create); struct ldlm_resource *ldlm_resource_getref(struct ldlm_resource *res); -int ldlm_resource_put(struct ldlm_resource *res); +int ldlm_resource_putref(struct ldlm_resource *res); void ldlm_resource_add_lock(struct ldlm_resource *res, struct list_head *head, struct ldlm_lock *lock); void ldlm_resource_unlink_lock(struct ldlm_lock *lock); diff --git a/lustre/include/linux/lustre_lib.h b/lustre/include/linux/lustre_lib.h index b5c7e30..da5cc81 100644 --- a/lustre/include/linux/lustre_lib.h +++ b/lustre/include/linux/lustre_lib.h @@ -29,21 +29,11 @@ # include #else # include -#include /* XXX just for LASSERT! */ #endif +#include /* XXX just for LASSERT! */ #include #include -#if BITS_PER_LONG > 32 -#define LPU64 "%lu" -#define LPD64 "%ld" -#define LPX64 "%#lx" -#else -#define LPU64 "%Lu" -#define LPD64 "%Ld" -#define LPX64 "%#Lx" -#endif - #ifdef __KERNEL__ /* l_net.c */ struct ptlrpc_request; diff --git a/lustre/include/linux/obd.h b/lustre/include/linux/obd.h index c028a0e..cb72b5b 100644 --- a/lustre/include/linux/obd.h +++ b/lustre/include/linux/obd.h @@ -273,7 +273,7 @@ struct obd_device { }; struct obd_ops { - int (*o_iocontrol)(long cmd, struct lustre_handle *, int len, + int (*o_iocontrol)(unsigned int cmd, struct lustre_handle *, int len, void *karg, void *uarg); int (*o_get_info)(struct lustre_handle *, obd_count keylen, void *key, obd_count *vallen, void **val); diff --git a/lustre/include/linux/obd_class.h b/lustre/include/linux/obd_class.h index 7efd82d..197de84 100644 --- a/lustre/include/linux/obd_class.h +++ b/lustre/include/linux/obd_class.h @@ -469,7 +469,7 @@ static inline int obd_commitrw(int cmd, struct lustre_handle *conn, RETURN(rc); } -static inline int obd_iocontrol(int cmd, struct lustre_handle *conn, +static inline int obd_iocontrol(unsigned int cmd, struct lustre_handle *conn, int len, void *karg, void *uarg) { struct obd_export *exp; diff --git a/lustre/include/linux/obd_snap_support.h b/lustre/include/linux/obd_snap_support.h index 75ec08a..fd8baa4 100644 --- a/lustre/include/linux/obd_snap_support.h +++ b/lustre/include/linux/obd_snap_support.h @@ -73,7 +73,7 @@ inline struct lustre_handle *child_conn(struct lustre_handle *conn); int snap_deleteobj(obd_id id, obd_gr group, void *data); int snap_restoreobj(obd_id id, obd_gr group, void *data); int snap_printobj(obd_id id, obd_gr group, void *data); -int snap_iocontrol(int cmd, struct lustre_handle *conn, int len, void *karg, void *uarg); +int snap_iocontrol(unsigned int cmd, struct lustre_handle *conn, int len, void *karg, void *uarg); /* In the future, this function may have to deal with offsets into the obdmd. * Currently, we assume we have the whole obdmd struct. diff --git a/lustre/ldlm/ldlm_lock.c b/lustre/ldlm/ldlm_lock.c index 59818f8..83a6661 100644 --- a/lustre/ldlm/ldlm_lock.c +++ b/lustre/ldlm/ldlm_lock.c @@ -91,6 +91,7 @@ char *ldlm_it2str(int it) } extern kmem_cache_t *ldlm_lock_slab; +struct lustre_lock ldlm_handle_lock; static int ldlm_plain_compat(struct ldlm_lock *a, struct ldlm_lock *b); @@ -141,7 +142,7 @@ void ldlm_unregister_intent(void) struct ldlm_lock *ldlm_lock_get(struct ldlm_lock *lock) { l_lock(&lock->l_resource->lr_namespace->ns_lock); - lock->l_refc++; + atomic_inc(&lock->l_refc); ldlm_resource_getref(lock->l_resource); l_unlock(&lock->l_resource->lr_namespace->ns_lock); return lock; @@ -153,23 +154,21 @@ void ldlm_lock_put(struct ldlm_lock *lock) ENTRY; l_lock(&ns->ns_lock); - lock->l_refc--; - //LDLM_DEBUG(lock, "after refc--"); - if (lock->l_refc < 0) - LBUG(); + atomic_dec(&lock->l_refc); + LASSERT(atomic_read(&lock->l_refc) >= 0); - if (ldlm_resource_put(lock->l_resource)) { - LASSERT(lock->l_refc == 0); + if (ldlm_resource_putref(lock->l_resource)) { + LASSERT(atomic_read(&lock->l_refc) == 0); lock->l_resource = NULL; } if (lock->l_parent) LDLM_LOCK_PUT(lock->l_parent); - if (lock->l_refc == 0 && (lock->l_flags & LDLM_FL_DESTROYED)) { + if (atomic_read(&lock->l_refc) == 0) { + LASSERT(lock->l_destroyed); l_unlock(&ns->ns_lock); LDLM_DEBUG(lock, "final lock_put on destroyed lock, freeing"); - //spin_lock(&ldlm_handle_lock); spin_lock(&ns->ns_counter_lock); ns->ns_locks--; spin_unlock(&ns->ns_counter_lock); @@ -180,7 +179,6 @@ void ldlm_lock_put(struct ldlm_lock *lock) ptlrpc_put_connection(lock->l_export->exp_connection); memset(lock, 0x5a, sizeof(*lock)); kmem_cache_free(ldlm_lock_slab, lock); - //spin_unlock(&ldlm_handle_lock); CDEBUG(D_MALLOC, "kfreed 'lock': %d at %p (tot 0).\n", sizeof(*lock), lock); } else @@ -189,6 +187,19 @@ void ldlm_lock_put(struct ldlm_lock *lock) EXIT; } +void ldlm_lock_remove_from_lru(struct ldlm_lock *lock) +{ + ENTRY; + l_lock(&lock->l_resource->lr_namespace->ns_lock); + if (!list_empty(&lock->l_lru)) { + list_del_init(&lock->l_lru); + lock->l_resource->lr_namespace->ns_nr_unused--; + LASSERT(lock->l_resource->lr_namespace->ns_nr_unused >= 0); + } + l_unlock(&lock->l_resource->lr_namespace->ns_lock); + EXIT; +} + void ldlm_lock_destroy(struct ldlm_lock *lock) { ENTRY; @@ -210,17 +221,17 @@ void ldlm_lock_destroy(struct ldlm_lock *lock) LBUG(); } - if (lock->l_flags & LDLM_FL_DESTROYED) { + if (lock->l_destroyed) { LASSERT(list_empty(&lock->l_lru)); l_unlock(&lock->l_resource->lr_namespace->ns_lock); EXIT; return; } + lock->l_destroyed = 1; - list_del_init(&lock->l_lru); list_del(&lock->l_export_chain); lock->l_export = NULL; - lock->l_flags |= LDLM_FL_DESTROYED; + ldlm_lock_remove_from_lru(lock); /* Wake anyone waiting for this lock */ /* FIXME: I should probably add yet another flag, instead of using @@ -258,7 +269,7 @@ static struct ldlm_lock *ldlm_lock_new(struct ldlm_lock *parent, lock->l_resource = resource; /* this refcount matches the one of the resource passed in which is not being put away */ - lock->l_refc = 1; + atomic_set(&lock->l_refc, 1); INIT_LIST_HEAD(&lock->l_children); INIT_LIST_HEAD(&lock->l_res_link); INIT_LIST_HEAD(&lock->l_lru); @@ -288,7 +299,7 @@ int ldlm_lock_change_resource(struct ldlm_lock *lock, __u64 new_resid[3]) { struct ldlm_namespace *ns = lock->l_resource->lr_namespace; struct ldlm_resource *oldres = lock->l_resource; - int i; + int i, refc; ENTRY; l_lock(&ns->ns_lock); @@ -312,15 +323,16 @@ int ldlm_lock_change_resource(struct ldlm_lock *lock, __u64 new_resid[3]) } /* move references over */ - for (i = 0; i < lock->l_refc; i++) { + refc = atomic_read(&lock->l_refc); + for (i = 0; i < refc; i++) { int rc; ldlm_resource_getref(lock->l_resource); - rc = ldlm_resource_put(oldres); - if (rc == 1 && i != lock->l_refc - 1) + rc = ldlm_resource_putref(oldres); + if (rc == 1 && i != refc - 1) LBUG(); } /* compensate for the initial get above.. */ - ldlm_resource_put(lock->l_resource); + ldlm_resource_putref(lock->l_resource); l_unlock(&ns->ns_lock); RETURN(0); @@ -341,8 +353,8 @@ void ldlm_lock2handle(struct ldlm_lock *lock, struct lustre_handle *lockh) * Return NULL if flag already set */ -struct ldlm_lock *__ldlm_handle2lock(struct lustre_handle *handle, - int strict, int flags) +struct ldlm_lock *__ldlm_handle2lock(struct lustre_handle *handle, int strict, + int flags) { struct ldlm_lock *lock = NULL, *retval = NULL; ENTRY; @@ -352,7 +364,6 @@ struct ldlm_lock *__ldlm_handle2lock(struct lustre_handle *handle, if (!handle->addr) RETURN(NULL); - //spin_lock(&ldlm_handle_lock); lock = (struct ldlm_lock *)(unsigned long)(handle->addr); if (!kmem_cache_validate(ldlm_lock_slab, (void *)lock)) { //CERROR("bogus lock %p\n", lock); @@ -360,8 +371,8 @@ struct ldlm_lock *__ldlm_handle2lock(struct lustre_handle *handle, } if (lock->l_random != handle->cookie) { - //CERROR("bogus cookie: lock %p has "LPX64" vs. handle "LPX64"\n", - // lock, lock->l_random, handle->cookie); + //CERROR("bogus cookie: lock %p has "LPX64" vs. handle "LPX64 + // "\n", lock, lock->l_random, handle->cookie); GOTO(out2, NULL); } if (!lock->l_resource) { @@ -376,7 +387,7 @@ struct ldlm_lock *__ldlm_handle2lock(struct lustre_handle *handle, } l_lock(&lock->l_resource->lr_namespace->ns_lock); - if (strict && lock->l_flags & LDLM_FL_DESTROYED) { + if (strict && lock->l_destroyed) { CERROR("lock already destroyed: lock %p\n", lock); //LDLM_DEBUG(lock, "ldlm_handle2lock(%p)", lock); GOTO(out, NULL); @@ -395,7 +406,6 @@ struct ldlm_lock *__ldlm_handle2lock(struct lustre_handle *handle, out: l_unlock(&lock->l_resource->lr_namespace->ns_lock); out2: - //spin_unlock(&ldlm_handle_lock); return retval; } @@ -455,13 +465,7 @@ void ldlm_lock_addref(struct lustre_handle *lockh, __u32 mode) void ldlm_lock_addref_internal(struct ldlm_lock *lock, __u32 mode) { l_lock(&lock->l_resource->lr_namespace->ns_lock); - - if (!list_empty(&lock->l_lru)) { - list_del_init(&lock->l_lru); - lock->l_resource->lr_namespace->ns_nr_unused--; - LASSERT(lock->l_resource->lr_namespace->ns_nr_unused >= 0); - } - + ldlm_lock_remove_from_lru(lock); if (mode == LCK_NL || mode == LCK_CR || mode == LCK_PR) lock->l_readers++; else @@ -612,7 +616,7 @@ static struct ldlm_lock *search_queue(struct list_head *queue, ldlm_mode_t mode, if (lock == old_lock) continue; - if (lock->l_flags & (LDLM_FL_CBPENDING | LDLM_FL_DESTROYED)) + if (lock->l_flags & LDLM_FL_CBPENDING) continue; if (lock->l_req_mode != mode) @@ -623,6 +627,9 @@ static struct ldlm_lock *search_queue(struct list_head *queue, ldlm_mode_t mode, lock->l_extent.end < extent->end)) continue; + if (lock->l_destroyed) + continue; + ldlm_lock_addref_internal(lock, mode); return lock; } @@ -676,7 +683,7 @@ int ldlm_lock_match(struct ldlm_namespace *ns, __u64 *res_id, __u32 type, EXIT; out: - ldlm_resource_put(res); + ldlm_resource_putref(res); l_unlock(&ns->ns_lock); if (lock) { @@ -716,7 +723,7 @@ struct ldlm_lock *ldlm_lock_create(struct ldlm_namespace *ns, lock = ldlm_lock_new(parent_lock, res); if (lock == NULL) { - ldlm_resource_put(res); + ldlm_resource_putref(res); RETURN(NULL); } @@ -961,7 +968,7 @@ void ldlm_cancel_locks_for_export(struct obd_export *exp) LDLM_DEBUG(lock, "export %p", exp); ldlm_lock_cancel(lock); ldlm_reprocess_all(res); - ldlm_resource_put(res); + ldlm_resource_putref(res); } } diff --git a/lustre/ldlm/ldlm_lockd.c b/lustre/ldlm/ldlm_lockd.c index 892bf94..bd2dd09 100644 --- a/lustre/ldlm/ldlm_lockd.c +++ b/lustre/ldlm/ldlm_lockd.c @@ -32,6 +32,7 @@ extern kmem_cache_t *ldlm_resource_slab; extern kmem_cache_t *ldlm_lock_slab; +extern struct lustre_lock ldlm_handle_lock; extern struct list_head ldlm_namespace_list; extern int (*mds_reint_p)(int offset, struct ptlrpc_request *req); extern int (*mds_getattr_name_p)(int offset, struct ptlrpc_request *req); @@ -734,6 +735,8 @@ static int __init ldlm_init(void) return -ENOMEM; } + l_lock_init(&ldlm_handle_lock); + return 0; } diff --git a/lustre/ldlm/ldlm_request.c b/lustre/ldlm/ldlm_request.c index ccb7611..7d449ef 100644 --- a/lustre/ldlm/ldlm_request.c +++ b/lustre/ldlm/ldlm_request.c @@ -78,9 +78,9 @@ int ldlm_completion_ast(struct ldlm_lock *lock, int flags) /* Go to sleep until the lock is granted or cancelled. */ rc = l_wait_event(lock->l_waitq, ((lock->l_req_mode == lock->l_granted_mode) || - (lock->l_flags & LDLM_FL_DESTROYED)), &lwi); + lock->l_destroyed), &lwi); - if (lock->l_flags & LDLM_FL_DESTROYED) { + if (lock->l_destroyed) { LDLM_DEBUG(lock, "client-side enqueue waking up: destroyed"); RETURN(-EIO); } @@ -518,7 +518,7 @@ int ldlm_cancel_lru(struct ldlm_namespace *ns) w->w_lock = LDLM_LOCK_GET(lock); list_add(&w->w_list, &list); - list_del_init(&lock->l_lru); + ldlm_lock_remove_from_lru(lock); if (--count == 0) break; @@ -600,7 +600,7 @@ int ldlm_cli_cancel_unused_resource(struct ldlm_namespace *ns, OBD_FREE(w, sizeof(*w)); } - ldlm_resource_put(res); + ldlm_resource_putref(res); RETURN(0); } @@ -614,6 +614,7 @@ int ldlm_cli_cancel_unused(struct ldlm_namespace *ns, __u64 *res_id, int flags) { int i; + ENTRY; if (res_id) RETURN(ldlm_cli_cancel_unused_resource(ns, res_id, flags)); @@ -633,12 +634,12 @@ int ldlm_cli_cancel_unused(struct ldlm_namespace *ns, __u64 *res_id, if (rc) CERROR("cancel_unused_res ("LPU64"): %d\n", res->lr_name[0], rc); - ldlm_resource_put(res); + ldlm_resource_putref(res); } } l_unlock(&ns->ns_lock); - return ELDLM_OK; + RETURN(ELDLM_OK); } /* Lock iterators. */ @@ -709,7 +710,7 @@ int ldlm_namespace_foreach(struct ldlm_namespace *ns, ldlm_iterator_t iter, ldlm_resource_getref(res); rc = ldlm_resource_foreach(res, ldlm_iter_helper, &helper); - ldlm_resource_put(res); + ldlm_resource_putref(res); if (rc == LDLM_ITER_STOP) GOTO(out, rc); } diff --git a/lustre/ldlm/ldlm_resource.c b/lustre/ldlm/ldlm_resource.c index 60a351f..64ec591 100644 --- a/lustre/ldlm/ldlm_resource.c +++ b/lustre/ldlm/ldlm_resource.c @@ -182,13 +182,13 @@ int ldlm_namespace_cleanup(struct ldlm_namespace *ns, int local_only) * local_only (which is only used by recovery). In that * case, we probably still have outstanding lock refs * which reference these resources. -phil */ - if (!ldlm_resource_put(res) && !local_only) { + if (!ldlm_resource_putref(res) && !local_only) { CERROR("Resource refcount nonzero (%d) after " "lock cleanup; forcing cleanup.\n", atomic_read(&res->lr_refcount)); ldlm_resource_dump(res); atomic_set(&res->lr_refcount, 1); - ldlm_resource_put(res); + ldlm_resource_putref(res); } } } @@ -286,6 +286,7 @@ static struct ldlm_resource *ldlm_resource_add(struct ldlm_namespace *ns, ns->ns_resources++; spin_unlock(&ns->ns_counter_lock); + l_lock(&ns->ns_lock); memcpy(res->lr_name, name, sizeof(res->lr_name)); res->lr_namespace = ns; ns->ns_refcount++; @@ -296,12 +297,13 @@ static struct ldlm_resource *ldlm_resource_add(struct ldlm_namespace *ns, bucket = ns->ns_hash + ldlm_hash_fn(parent, name); list_add(&res->lr_hash, bucket); - if (parent == NULL) + if (parent == NULL) { list_add(&res->lr_childof, &ns->ns_root_list); - else { + } else { res->lr_parent = parent; list_add(&res->lr_childof, &parent->lr_children); } + l_unlock(&ns->ns_lock); RETURN(res); } @@ -348,37 +350,49 @@ struct ldlm_resource *ldlm_resource_get(struct ldlm_namespace *ns, struct ldlm_resource *ldlm_resource_getref(struct ldlm_resource *res) { atomic_inc(&res->lr_refcount); + CDEBUG(D_INFO, "getref res: %p count: %d\n", res, + atomic_read(&res->lr_refcount)); return res; } /* Returns 1 if the resource was freed, 0 if it remains. */ -int ldlm_resource_put(struct ldlm_resource *res) +int ldlm_resource_putref(struct ldlm_resource *res) { int rc = 0; if (atomic_dec_and_test(&res->lr_refcount)) { struct ldlm_namespace *ns = res->lr_namespace; ENTRY; + CDEBUG(D_INFO, "putref res: %p count: %d\n", res, + atomic_read(&res->lr_refcount)); l_lock(&ns->ns_lock); if (atomic_read(&res->lr_refcount) != 0) { /* We lost the race. */ l_unlock(&ns->ns_lock); - goto out; + RETURN(rc); } - if (!list_empty(&res->lr_granted)) + if (!list_empty(&res->lr_granted)) { + ldlm_resource_dump(res); LBUG(); + } - if (!list_empty(&res->lr_converting)) + if (!list_empty(&res->lr_converting)) { + ldlm_resource_dump(res); LBUG(); + } - if (!list_empty(&res->lr_waiting)) + if (!list_empty(&res->lr_waiting)) { + ldlm_resource_dump(res); LBUG(); + } - if (!list_empty(&res->lr_children)) + if (!list_empty(&res->lr_children)) { + ldlm_resource_dump(res); LBUG(); + } ns->ns_refcount--; list_del(&res->lr_hash); @@ -395,9 +409,10 @@ int ldlm_resource_put(struct ldlm_resource *res) rc = 1; } else { ENTRY; + CDEBUG(D_INFO, "putref res: %p count: %d\n", res, + atomic_read(&res->lr_refcount)); out: - if (atomic_read(&res->lr_refcount) < 0) - LBUG(); + LASSERT(atomic_read(&res->lr_refcount) >= 0); } RETURN(rc); @@ -411,8 +426,7 @@ void ldlm_resource_add_lock(struct ldlm_resource *res, struct list_head *head, ldlm_resource_dump(res); ldlm_lock_dump(lock); - if (!list_empty(&lock->l_res_link)) - LBUG(); + LASSERT(list_empty(&lock->l_res_link)); list_add(&lock->l_res_link, head); l_unlock(&res->lr_namespace->ns_lock); diff --git a/lustre/llite/namei.c b/lustre/llite/namei.c index d3e5769..9670af0 100644 --- a/lustre/llite/namei.c +++ b/lustre/llite/namei.c @@ -306,7 +306,6 @@ int ll_intent_lock(struct inode *parent, struct dentry **de, } offset = 0; } else { - struct ll_inode_info *lli = ll_i2info(parent); obd_flag valid; int mode; @@ -653,7 +652,6 @@ static int ll_create(struct inode *dir, struct dentry *dentry, int mode) RETURN(PTR_ERR(inode)); if (it && it->it_disposition) { - struct ll_inode_info *lli = ll_i2info(inode); d_instantiate(dentry, inode); } else { /* no directory data updates when intents rule */ diff --git a/lustre/lov/lov_obd.c b/lustre/lov/lov_obd.c index 1b92409..e7cf3cb 100644 --- a/lustre/lov/lov_obd.c +++ b/lustre/lov/lov_obd.c @@ -1378,7 +1378,7 @@ static int lov_statfs(struct lustre_handle *conn, struct obd_statfs *osfs) RETURN(rc); } -static int lov_iocontrol(long cmd, struct lustre_handle *conn, int len, +static int lov_iocontrol(unsigned int cmd, struct lustre_handle *conn, int len, void *karg, void *uarg) { struct obd_device *obddev = class_conn2obd(conn); diff --git a/lustre/mdc/mdc_request.c b/lustre/mdc/mdc_request.c index 16f6ca8..79b07ba 100644 --- a/lustre/mdc/mdc_request.c +++ b/lustre/mdc/mdc_request.c @@ -521,6 +521,7 @@ int mdc_close(struct lustre_handle *conn, obd_id ino, int type, struct mds_body *body; int rc, size = sizeof(*body); struct ptlrpc_request *req; + ENTRY; req = ptlrpc_prep_req(class_conn2cliimp(conn), MDS_CLOSE, 1, &size, NULL); diff --git a/lustre/mds/handler.c b/lustre/mds/handler.c index bfdb3de..ee12652 100644 --- a/lustre/mds/handler.c +++ b/lustre/mds/handler.c @@ -1783,7 +1783,7 @@ static int mdt_cleanup(struct obd_device *obddev) RETURN(0); } -extern int mds_iocontrol(long cmd, struct lustre_handle *conn, +extern int mds_iocontrol(unsigned int cmd, struct lustre_handle *conn, int len, void *karg, void *uarg); /* use obd ops to offer management infrastructure */ diff --git a/lustre/mds/mds_fs.c b/lustre/mds/mds_fs.c index 811c801..163a45f 100644 --- a/lustre/mds/mds_fs.c +++ b/lustre/mds/mds_fs.c @@ -32,7 +32,8 @@ struct mds_fs_type { char *mft_name; }; -#define MDS_MAX_CLIENTS 1024 +/* This limit is arbitrary, but for now we fit it in 1 page (32k clients) */ +#define MDS_MAX_CLIENTS (PAGE_SIZE * 8) #define MDS_MAX_CLIENT_WORDS (MDS_MAX_CLIENTS / sizeof(unsigned long)) static unsigned long last_rcvd_slots[MDS_MAX_CLIENT_WORDS]; diff --git a/lustre/mds/mds_lov.c b/lustre/mds/mds_lov.c index a7304de..ba9a750 100644 --- a/lustre/mds/mds_lov.c +++ b/lustre/mds/mds_lov.c @@ -154,7 +154,7 @@ out: RETURN(rc); } -int mds_iocontrol(long cmd, struct lustre_handle *conn, +int mds_iocontrol(unsigned int cmd, struct lustre_handle *conn, int len, void *karg, void *uarg) { struct obd_device *obd = class_conn2obd(conn); diff --git a/lustre/obdclass/Makefile.am b/lustre/obdclass/Makefile.am index 44c7ec7..d7df0bb 100644 --- a/lustre/obdclass/Makefile.am +++ b/lustre/obdclass/Makefile.am @@ -8,6 +8,7 @@ obdclass_SOURCES = debug.c genops.c class_obd.c sysctl.c uuid.c lprocfs_status.c include $(top_srcdir)/Rules lustre_build_version: perl $(top_srcdir)/scripts/version_tag.pl $(top_srcdir) > tmpver - diff -u tmpver $(top_builddir)/include/linux/lustre_build_version.h &&\ + diff -u $(top_builddir)/include/linux/lustre_build_version.h tmpver \ + 2> /dev/null &&\ $(RM) tmpver || \ mv tmpver $(top_builddir)/include/linux/lustre_build_version.h diff --git a/lustre/obdclass/class_obd.c b/lustre/obdclass/class_obd.c index a780f10..32e8c08 100644 --- a/lustre/obdclass/class_obd.c +++ b/lustre/obdclass/class_obd.c @@ -132,10 +132,19 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, struct obd_ioctl_data *data; struct obd_device *obd = filp->private_data; struct lustre_handle conn; - int err = 0, len = 0; + int err = 0, len = 0, serialised = 0; ENTRY; - down(&obd_conf_sem); + switch (cmd) { + case OBD_IOC_BRW_WRITE: + case OBD_IOC_BRW_READ: + case OBD_IOC_GETATTR: + break; + default: + down(&obd_conf_sem); + serialised = 1; + break; + } if (!obd && cmd != OBD_IOC_DEVICE && cmd != TCGETS && cmd != OBD_IOC_LIST && cmd != OBD_GET_VERSION && @@ -519,7 +528,8 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, out: if (buf) OBD_FREE(buf, len); - up(&obd_conf_sem); + if (serialised) + up(&obd_conf_sem); RETURN(err); } /* obd_class_ioctl */ diff --git a/lustre/obdecho/echo_client.c b/lustre/obdecho/echo_client.c index 763ddb8..4ccc043 100644 --- a/lustre/obdecho/echo_client.c +++ b/lustre/obdecho/echo_client.c @@ -31,7 +31,7 @@ #include #include -static int echo_iocontrol(long cmd, struct lustre_handle *obdconn, int len, +static int echo_iocontrol(unsigned int cmd, struct lustre_handle *obdconn, int len, void *karg, void *uarg) { struct obd_device *obd = class_conn2obd(obdconn); @@ -182,7 +182,8 @@ static int echo_iocontrol(long cmd, struct lustre_handle *obdconn, int len, GOTO(out, rc); } default: - return -ENOTTY; + CERROR ("echo_ioctl(): unrecognised ioctl %#lx\n", cmd); + GOTO (out, rc = -ENOTTY); } out: diff --git a/lustre/osc/osc_request.c b/lustre/osc/osc_request.c index a5302ef..de403b5 100644 --- a/lustre/osc/osc_request.c +++ b/lustre/osc/osc_request.c @@ -774,7 +774,7 @@ static int osc_statfs(struct lustre_handle *conn, struct obd_statfs *osfs) return rc; } -static int osc_iocontrol(long cmd, struct lustre_handle *conn, int len, +static int osc_iocontrol(unsigned int cmd, struct lustre_handle *conn, int len, void *karg, void *uarg) { struct obd_device *obddev = class_conn2obd(conn); @@ -877,6 +877,7 @@ static int osc_iocontrol(long cmd, struct lustre_handle *conn, int len, GOTO(out, err); } default: + CERROR ("osc_ioctl(): unrecognised ioctl %#lx\n", cmd); GOTO(out, err = -ENOTTY); } out: diff --git a/lustre/ptlrpc/client.c b/lustre/ptlrpc/client.c index 04a76f2..4ab7903 100644 --- a/lustre/ptlrpc/client.c +++ b/lustre/ptlrpc/client.c @@ -391,6 +391,7 @@ static int ptlrpc_check_reply(struct ptlrpc_request *req) DEBUG_REQ(D_ERROR, req, "RESTART:"); GOTO(out, rc = 1); } + EXIT; out: DEBUG_REQ(D_NET, req, "rc = %d for", rc); return rc; @@ -443,6 +444,10 @@ void ptlrpc_free_committed(struct obd_import *imp) struct ptlrpc_request *req; ENTRY; +#ifndef __arch_um__ + LASSERT(spin_is_locked(&imp->imp_lock)); +#endif + CDEBUG(D_HA, "committing for xid "LPU64", last_committed "LPU64"\n", imp->imp_peer_last_xid, imp->imp_peer_committed_transno); @@ -455,10 +460,12 @@ void ptlrpc_free_committed(struct obd_import *imp) } /* not yet committed */ - if (req->rq_transno > imp->imp_peer_committed_transno) + if (req->rq_transno > imp->imp_peer_committed_transno) { + DEBUG_REQ(D_HA, req, "stopping search"); break; + } - DEBUG_REQ(D_HA, req, "committing (last_committed %Lu)", + DEBUG_REQ(D_HA, req, "committing (last_committed "LPU64")", imp->imp_peer_committed_transno); __ptlrpc_req_finished(req, 1); } diff --git a/lustre/ptlrpc/rpc.c b/lustre/ptlrpc/rpc.c index c721993..eb6acb1 100644 --- a/lustre/ptlrpc/rpc.c +++ b/lustre/ptlrpc/rpc.c @@ -71,7 +71,7 @@ int connmgr_cleanup(struct obd_device *dev) RETURN(0); } -int connmgr_iocontrol(long cmd, struct lustre_handle *hdl, int len, void *karg, +int connmgr_iocontrol(unsigned int cmd, struct lustre_handle *hdl, int len, void *karg, void *uarg) { struct ptlrpc_connection *conn = NULL; diff --git a/lustre/scripts/version_tag.pl b/lustre/scripts/version_tag.pl index e810f3f..a92fef4 100644 --- a/lustre/scripts/version_tag.pl +++ b/lustre/scripts/version_tag.pl @@ -135,7 +135,8 @@ sub generate_ver($$$) localtime($mtime); $year += 1900; $mon++; - my $show_last = $year . $mon . $mday . $hour . $min . $sec; + my $show_last = sprintf("%04d%02d%02d%02d%02d%02d", $year, $mon, $mday, + $hour, $min, $sec); print "#define BUILD_VERSION \""; if ($pristine) { diff --git a/lustre/tests/.cvsignore b/lustre/tests/.cvsignore index 1ad2510..5563923 100644 --- a/lustre/tests/.cvsignore +++ b/lustre/tests/.cvsignore @@ -26,3 +26,4 @@ mkdirmany lovstripe *.xml stat +setuid diff --git a/lustre/tests/acceptance-small.sh b/lustre/tests/acceptance-small.sh index 5b81611..06c4a84 100755 --- a/lustre/tests/acceptance-small.sh +++ b/lustre/tests/acceptance-small.sh @@ -9,6 +9,7 @@ set -vxe [ "$RSIZE" ] || RSIZE=64 [ "$UID" ] || UID=1000 [ "$MNT" ] || MNT=/mnt/lustre +[ "$TMP" ] || TMP=/tmp [ "$COUNT" ] || COUNT=1000 [ "$DEBUG_OFF" ] || DEBUG_OFF="eval echo 0 > /proc/sys/portals/debug" @@ -75,7 +76,7 @@ for NAME in $CONFIGS; do fi if [ "$FSX" != "no" ]; then $DEBUG_OFF - ./fsx -c 50 -p 1000 -l 1024000 -N $(($COUNT * 100)) $MNT/fsxfile + ./fsx -c 50 -p 1000 -P $TMP -l 1024000 -N $(($COUNT * 100)) $MNT/fsxfile sh llmountcleanup.sh #sh llrmount.sh fi diff --git a/lustre/tests/fsx.c b/lustre/tests/fsx.c index e7c1495..717b8d4 100644 --- a/lustre/tests/fsx.c +++ b/lustre/tests/fsx.c @@ -41,6 +41,7 @@ # include # include # include +# include #endif #include #include @@ -64,6 +65,7 @@ struct log_entry { int operation; + struct timeval tv; int args[3]; }; @@ -92,6 +94,8 @@ char *original_buf; /* a pointer to the original data */ char *good_buf; /* a pointer to the correct data */ char *temp_buf; /* a pointer to the current data */ char *fname; /* name of our test file */ +char logfile[1024]; /* name of our log file */ +char goodfile[1024]; /* name of our test file */ int fd; /* fd for our test file */ off_t file_size = 0; @@ -171,11 +175,12 @@ prterr(char *prefix) void -log4(int operation, int arg0, int arg1, int arg2) +log4(int operation, int arg0, int arg1, int arg2, struct timeval *tv) { struct log_entry *le; le = &oplog[logptr]; + le->tv = *tv; le->operation = operation; if (closeopen) le->operation = ~ le->operation; @@ -207,8 +212,9 @@ logdump(void) int opnum; opnum = i+1 + (logcount/LOGSIZE)*LOGSIZE; - prt("%d(%d mod 256): ", opnum, opnum%256); lp = &oplog[i]; + prt("%d(%d mod 256): %lu.%lu ", opnum, opnum%256, + lp->tv.tv_sec, lp->tv.tv_usec); if ((closeopen = lp->operation < 0)) lp->operation = ~ lp->operation; @@ -325,8 +331,8 @@ report_failure(int status) if (good_buf) { save_buffer(good_buf, file_size, fsxgoodfd); prt("Correct content saved for comparison\n"); - prt("(maybe hexdump \"%s\" vs \"%s.fsxgood\")\n", - fname, fname); + prt("(maybe hexdump \"%s\" vs \"%s\")\n", + fname, goodfile); } close(fsxgoodfd); } @@ -422,24 +428,26 @@ check_trunc_hack(void) void doread(unsigned offset, unsigned size) { + struct timeval t; off_t ret; unsigned iret; offset -= offset % readbdy; + gettimeofday(&t, NULL); if (size == 0) { if (!quiet && testcalls > simulatedopcount) prt("skipping zero size read\n"); - log4(OP_SKIPPED, OP_READ, offset, size); + log4(OP_SKIPPED, OP_READ, offset, size, &t); return; } if (size + offset > file_size) { if (!quiet && testcalls > simulatedopcount) prt("skipping seek/read past end of file\n"); - log4(OP_SKIPPED, OP_READ, offset, size); + log4(OP_SKIPPED, OP_READ, offset, size, &t); return; } - log4(OP_READ, offset, size, 0); + log4(OP_READ, offset, size, 0, &t); if (testcalls <= simulatedopcount) return; @@ -450,8 +458,9 @@ doread(unsigned offset, unsigned size) (monitorstart == -1 || (offset + size > monitorstart && (monitorend == -1 || offset <= monitorend)))))) - prt("%lu read\t0x%x thru\t0x%x\t(0x%x bytes)\n", testcalls, - offset, offset + size - 1, size); + prt("%lu %lu.%lu read\t0x%x thru\t0x%x\t(0x%x bytes)\n", + testcalls, t.tv_sec, t.tv_usec, offset, offset + size - 1, + size); ret = lseek(fd, (off_t)offset, SEEK_SET); if (ret == (off_t)-1) { prterr("doread: lseek"); @@ -473,25 +482,27 @@ doread(unsigned offset, unsigned size) void domapread(unsigned offset, unsigned size) { + struct timeval t; unsigned pg_offset; unsigned map_size; char *p; offset -= offset % readbdy; + gettimeofday(&t, NULL); if (size == 0) { if (!quiet && testcalls > simulatedopcount) prt("skipping zero size read\n"); - log4(OP_SKIPPED, OP_MAPREAD, offset, size); + log4(OP_SKIPPED, OP_MAPREAD, offset, size, &t); return; } if (size + offset > file_size) { if (!quiet && testcalls > simulatedopcount) prt("skipping seek/read past end of file\n"); - log4(OP_SKIPPED, OP_MAPREAD, offset, size); + log4(OP_SKIPPED, OP_MAPREAD, offset, size, &t); return; } - log4(OP_MAPREAD, offset, size, 0); + log4(OP_MAPREAD, offset, size, 0, &t); if (testcalls <= simulatedopcount) return; @@ -502,14 +513,14 @@ domapread(unsigned offset, unsigned size) (monitorstart == -1 || (offset + size > monitorstart && (monitorend == -1 || offset <= monitorend)))))) - prt("%lu mapread\t0x%x thru\t0x%x\t(0x%x bytes)\n", testcalls, - offset, offset + size - 1, size); + prt("%lu %lu.%lu mapread\t0x%x thru\t0x%x\t(0x%x bytes)\n", + testcalls, t.tv_sec, t.tv_usec, offset, offset + size - 1, + size); pg_offset = offset & page_mask; map_size = pg_offset + size; - if ((p = (char *)mmap(0, map_size, PROT_READ, MAP_FILE | -MAP_SHARED, fd, + if ((p = (char *)mmap(0, map_size, PROT_READ, MAP_FILE | MAP_SHARED, fd, (off_t)(offset - pg_offset))) == (char *)-1) { prterr("domapread: mmap"); report_failure(190); @@ -539,18 +550,20 @@ gendata(char *original_buf, char *good_buf, unsigned offset, unsigned size) void dowrite(unsigned offset, unsigned size) { + struct timeval t; off_t ret; unsigned iret; offset -= offset % writebdy; + gettimeofday(&t, NULL); if (size == 0) { if (!quiet && testcalls > simulatedopcount) prt("skipping zero size write\n"); - log4(OP_SKIPPED, OP_WRITE, offset, size); + log4(OP_SKIPPED, OP_WRITE, offset, size, &t); return; } - log4(OP_WRITE, offset, size, file_size); + log4(OP_WRITE, offset, size, file_size, &t); gendata(original_buf, good_buf, offset, size); if (file_size < offset + size) { @@ -572,8 +585,9 @@ dowrite(unsigned offset, unsigned size) (monitorstart == -1 || (offset + size > monitorstart && (monitorend == -1 || offset <= monitorend)))))) - prt("%lu write\t0x%x thru\t0x%x\t(0x%x bytes)\n", testcalls, - offset, offset + size - 1, size); + prt("%lu %lu.%lu write\t0x%x thru\t0x%x\t(0x%x bytes)\n", + testcalls, t.tv_sec, t.tv_usec, offset, offset + size - 1, + size); ret = lseek(fd, (off_t)offset, SEEK_SET); if (ret == (off_t)-1) { prterr("dowrite: lseek"); @@ -594,21 +608,23 @@ dowrite(unsigned offset, unsigned size) void domapwrite(unsigned offset, unsigned size) { + struct timeval t; unsigned pg_offset; unsigned map_size; off_t cur_filesize; char *p; offset -= offset % writebdy; + gettimeofday(&t, NULL); if (size == 0) { if (!quiet && testcalls > simulatedopcount) prt("skipping zero size write\n"); - log4(OP_SKIPPED, OP_MAPWRITE, offset, size); + log4(OP_SKIPPED, OP_MAPWRITE, offset, size, &t); return; } cur_filesize = file_size; - log4(OP_MAPWRITE, offset, size, 0); + log4(OP_MAPWRITE, offset, size, 0, &t); gendata(original_buf, good_buf, offset, size); if (file_size < offset + size) { @@ -630,8 +646,9 @@ domapwrite(unsigned offset, unsigned size) (monitorstart == -1 || (offset + size > monitorstart && (monitorend == -1 || offset <= monitorend)))))) - prt("%lu mapwrite\t0x%x thru\t0x%x\t(0x%x bytes)\n", testcalls, - offset, offset + size - 1, size); + prt("%lu %lu.%lu mapwrite\t0x%x thru\t0x%x\t(0x%x bytes)\n", + testcalls, t.tv_sec, t.tv_usec, offset, offset + size - 1, + size); if (file_size > cur_filesize) { if (ftruncate(fd, file_size) == -1) { @@ -663,16 +680,18 @@ domapwrite(unsigned offset, unsigned size) void dotruncate(unsigned size) { + struct timeval t; int oldsize = file_size; size -= size % truncbdy; + gettimeofday(&t, NULL); if (size > biggest) { biggest = size; if (!quiet && testcalls > simulatedopcount) prt("truncating to largest ever: 0x%x\n", size); } - log4(OP_TRUNCATE, size, (unsigned)file_size, 0); + log4(OP_TRUNCATE, size, (unsigned)file_size, 0, &t); if (size > file_size) memset(good_buf + file_size, '\0', size - file_size); @@ -684,8 +703,8 @@ dotruncate(unsigned size) if ((progressinterval && testcalls % progressinterval == 0) || (debug && (monitorstart == -1 || monitorend == -1 || size <= monitorend))) - prt("%lu trunc\tfrom 0x%x to 0x%x\n", testcalls, oldsize, -size); + prt("%lu %lu.%lu trunc\tfrom 0x%x to 0x%x\n", + testcalls, t.tv_sec, t.tv_usec, oldsize, size); if (ftruncate(fd, (off_t)size) == -1) { prt("ftruncate1: %x\n", size); prterr("dotruncate: ftruncate"); @@ -723,11 +742,16 @@ writefileimage() void docloseopen(void) { + struct timeval t; + if (testcalls <= simulatedopcount) return; + log4(OP_CLOSEOPEN, file_size, (unsigned)file_size, 0, &t); + + gettimeofday(&t, NULL); if (debug) - prt("%lu close/open\n", testcalls); + prt("%lu %lu.%lu close/open\n", testcalls, t.tv_sec, t.tv_usec); if (close(fd)) { prterr("docloseopen: close"); report_failure(180); @@ -892,13 +916,19 @@ getnum(char *s, char **e) } +static const char *basename(const char *path) +{ + char *c = strrchr(path, '/'); + + return c ? c++ : path; +} + int main(int argc, char **argv) { int i, style, ch; char *endp; - char goodfile[1024]; - char logfile[1024]; + int dirpath = 0; goodfile[0] = 0; logfile[0] = 0; @@ -1007,6 +1037,7 @@ main(int argc, char **argv) strcat(goodfile, "/"); strncpy(logfile, optarg, sizeof(logfile)); strcat(logfile, "/"); + dirpath = 1; break; case 'R': mapped_reads = 0; @@ -1054,14 +1085,14 @@ main(int argc, char **argv) prterr(fname); exit(91); } - strncat(goodfile, fname, 256); + strncat(goodfile, dirpath ? basename(fname) : fname, 256); strcat (goodfile, ".fsxgood"); fsxgoodfd = open(goodfile, O_RDWR|O_CREAT|O_TRUNC, 0666); if (fsxgoodfd < 0) { prterr(goodfile); exit(92); } - strncat(logfile, fname, 256); + strncat(logfile, dirpath ? basename(fname) : fname, 256); strcat (logfile, ".fsxlog"); fsxlogf = fopen(logfile, "w"); if (fsxlogf == NULL) { diff --git a/lustre/tests/leak_finder.pl b/lustre/tests/leak_finder.pl index 1a92327..fbf1d00 100644 --- a/lustre/tests/leak_finder.pl +++ b/lustre/tests/leak_finder.pl @@ -1,19 +1,24 @@ #!/usr/bin/perl -w +use IO::Handle; + +STDOUT->autoflush(1); +STDERR->autoflush(1); + my ($line, $memory); my $debug_line = 0; while ($line = <>) { $debug_line++; my ($file, $func, $lno, $name, $size, $addr, $type); - if ($line =~ m/^.*\((.*):(\d+):(.*)\(\) \d+\+\d+\): [vk](.*) '(.*)': (\d+) at (.*) \(tot .*$/) { + if ($line =~ m/^.*\((.*):(\d+):(.*)\(\) (\d+ \| )?\d+\+\d+\): [vk](.*) '(.*)': (\d+) at (.*) \(tot .*$/) { $file = $1; $lno = $2; $func = $3; - $type = $4; - $name = $5; - $size = $6; - $addr = $7; + $type = $5; + $name = $6; + $size = $7; + $addr = $8; printf("%8s %6d bytes at %s called %s (%s:%s:%d)\n", $type, $size, $addr, $name, $file, $func, $lno); } else { @@ -29,14 +34,14 @@ while ($line = <>) { $memory->{$addr}->{debug_line} = $debug_line; } else { if (!defined($memory->{$addr})) { - print "*** Free without malloc ($size bytes at $addr, $file:$func:$lno)\n"; + print STDERR "*** Free without malloc ($size bytes at $addr, $file:$func:$lno)\n"; next; } my ($oldname, $oldsize, $oldfile, $oldfunc, $oldlno) = $memory->{$addr}; if ($memory->{$addr}->{size} != $size) { - print "*** Free different size ($memory->{$addr}->{size} alloced, $size freed).\n"; - print " malloc at $memory->{$addr}->{file}:$memory->{$addr}->{func}:$memory->{$addr}->{lno}, free at $file:$func:$lno\n"; + print STDERR "*** Free different size ($memory->{$addr}->{size} alloced, $size freed).\n"; + print STDERR " malloc at $memory->{$addr}->{file}:$memory->{$addr}->{func}:$memory->{$addr}->{lno}, free at $file:$func:$lno\n"; next; } @@ -44,10 +49,15 @@ while ($line = <>) { } } +# Sort leak output by allocation time +my @sorted = sort { + return $memory->{$a}->{debug_line} <=> $memory->{$b}->{debug_line}; +} keys(%{$memory}); + my $key; -foreach $key (keys(%{$memory})) { +foreach $key (@sorted) { my ($oldname, $oldsize, $oldfile, $oldfunc, $oldlno) = $memory->{$key}; - print "*** Leak: $memory->{$key}->{size} bytes allocated at $key ($memory->{$key}->{file}:$memory->{$key}->{func}:$memory->{$key}->{lno}, debug file line $memory->{$key}->{debug_line})\n"; + print STDERR "*** Leak: $memory->{$key}->{size} bytes allocated at $key ($memory->{$key}->{file}:$memory->{$key}->{func}:$memory->{$key}->{lno}, debug file line $memory->{$key}->{debug_line})\n"; } print "Done.\n"; diff --git a/lustre/tests/llmount2-hack.sh b/lustre/tests/llmount2-hack.sh index d17805a..495626c 100644 --- a/lustre/tests/llmount2-hack.sh +++ b/lustre/tests/llmount2-hack.sh @@ -2,16 +2,11 @@ # suggested boilerplate for test script LCONF=${LCONF:-../utils/lconf} -NAME=${NAME:-local2} +NAME=${NAME:-local2-hack} config=$NAME.xml -mkconfig=./$NAME.sh -if [ ! -f $config -o $mkconfig -nt $config ]; then - sh $mkconfig $config || exit 1 -fi - -${LCONF} -v --reformat --gdb $config || exit 2 +${LCONF} --reformat --gdb $config || exit 2 ../utils/lctl < - - - - - - - - - - - - - - - - - localhost - 988 - - - - extN - /tmp/mds1 - yes - - - - - - - - - - - - - - - extN - /tmp/ost1 - no - - - - - - - - - - - extN - /tmp/ost2 - no - - - - - - - - - - - - - /mnt/lustre - - diff --git a/lustre/tests/mcreate.c b/lustre/tests/mcreate.c index bc18aa7..9d48b11 100644 --- a/lustre/tests/mcreate.c +++ b/lustre/tests/mcreate.c @@ -10,14 +10,14 @@ int main(int argc, char ** argv) { int rc; - if (argc < 2) { + if (argc < 2) { printf("Usage %s filename\n", argv[0]); return 1; } - rc = mknod(argv[1], S_IFREG| 0444, 0); - if (rc) { + rc = mknod(argv[1], S_IFREG | 0644, 0); + if (rc) { printf("mknod(%s) error: %s\n", argv[1], strerror(errno)); } return rc; -} +} diff --git a/lustre/tests/testreq.c b/lustre/tests/testreq.c index bfcbb5e..a0ce1de 100644 --- a/lustre/tests/testreq.c +++ b/lustre/tests/testreq.c @@ -52,7 +52,10 @@ static void usage(char *argv0, int status) int main(int argc, char **argv) { - int fd, rc, c, cmd = 0; + int fd = 0; + int rc = 0; + int c = 0; + long cmd = 0; unsigned long arg; char *short_opts = "h", *name = argv[0]; static struct option long_opts[] = { diff --git a/lustre/utils/lfind.c b/lustre/utils/lfind.c index d488748..d0b4c49 100644 --- a/lustre/utils/lfind.c +++ b/lustre/utils/lfind.c @@ -222,7 +222,7 @@ processFile(const char *path, const struct stat *sp, int flag, struct FTW *ftwp) if (verbose) { printf("lmm_magic: 0x%x\n", lmm->lmm_magic); - printf("lmm_object_id: 0x%llx\n", lmm->lmm_object_id); + printf("lmm_object_id: "LPX64"\n", lmm->lmm_object_id); printf("lmm_stripe_offset: %d\n", lmm->lmm_stripe_offset); printf("lmm_stripe_count: %d\n", lmm->lmm_stripe_count); printf("lmm_ost_count: %d\n", lmm->lmm_ost_count); @@ -241,7 +241,7 @@ processFile(const char *path, const struct stat *sp, int flag, struct FTW *ftwp) for (i = 0; i < count; i++, loi++) if ((oid = loi->l_object_id)) - printf("%6d\t%5lld\n", i, oid); + printf("%6d\t%5lld\n", i, (long long)oid); if (query) return(0); diff --git a/lustre/utils/llanalyze b/lustre/utils/llanalyze index 5548f9b..d2c9273 100644 --- a/lustre/utils/llanalyze +++ b/lustre/utils/llanalyze @@ -61,10 +61,14 @@ $masks->{RPCTRACE} = 1 << 19; # /* recovery and failover */ sub extractpid { - $_ = shift; + $line = shift; # print "$_\n"; - /\(\) ([0-9]*)\+[0-9]*\):/; - return $1; + if ($line =~ m/\(\) ([0-9]*)\+[0-9]*\):/) { + return $1; + } + if ($line =~ m/\(\) ([0-9]*) | [0-9]*\+[0-9]*\):/) { + return $1; + } } sub entering diff --git a/lustre/utils/obd.c b/lustre/utils/obd.c index a6ccd29..4a3b336 100644 --- a/lustre/utils/obd.c +++ b/lustre/utils/obd.c @@ -293,8 +293,8 @@ int do_disconnect(char *func, int verbose) rc = ioctl(fd, OBD_IOC_DISCONNECT, &data); if (rc < 0) { - fprintf(stderr, "error: %s: %x %s\n", cmdname(func), - OBD_IOC_DISCONNECT, strerror(errno)); + fprintf(stderr, "error: %s: OPD_IOC_DISCONNECT %s\n", + cmdname(func),strerror(errno)); } else { if (verbose) printf("%s: disconnected conn "LPX64"\n", cmdname(func), @@ -452,8 +452,8 @@ int jt_obd_connect(int argc, char **argv) rc = ioctl(fd, OBD_IOC_CONNECT, &data); if (rc < 0) - fprintf(stderr, "error: %s: %x %s\n", cmdname(argv[0]), - OBD_IOC_CONNECT, strerror(rc = errno)); + fprintf(stderr, "error: %s: OBD_IOC_CONNECT %s\n", + cmdname(argv[0]), strerror(rc = errno)); else { conn_addr = data.ioc_addr; conn_cookie = data.ioc_cookie; @@ -741,8 +741,8 @@ int jt_obd_attach(int argc, char **argv) IOC_PACK(argv[0], data); rc = ioctl(fd, OBD_IOC_ATTACH, buf); if (rc < 0) - fprintf(stderr, "error: %s: %x %s\n", cmdname(argv[0]), - OBD_IOC_ATTACH, strerror(rc = errno)); + fprintf(stderr, "error: %s: OBD_IOC_ATTACH %s\n", + cmdname(argv[0]), strerror(rc = errno)); else if (argc == 3) { char name[1024]; if (strlen(argv[2]) > 128) { @@ -1088,8 +1088,8 @@ int jt_obd_test_getattr(int argc, char **argv) rc = ioctl(fd, OBD_IOC_GETATTR, &data); SHMEM_BUMP(); if (rc < 0) { - fprintf(stderr, "error: %s: #"LPD64" - %s\n", - cmdname(argv[0]), i, strerror(rc = errno)); + fprintf(stderr, "error: %s: #"LPD64" - %d:%s\n", + cmdname(argv[0]), i, errno, strerror(rc = errno)); break; } else { if (be_verbose @@ -1272,7 +1272,7 @@ int jt_obd_lov_setconfig(int argc, char **argv) if (strlen(argv[1]) > sizeof(desc.ld_uuid) - 1) { fprintf(stderr, - "error: %s: LOV uuid '%s' longer than %d characters\n", + "error: %s: LOV uuid '%s' longer than %zd characters\n", cmdname(argv[0]), argv[1], sizeof(desc.ld_uuid) - 1); return -EINVAL; } @@ -1383,7 +1383,7 @@ int jt_obd_lov_getconfig(int argc, char **argv) if (strlen(argv[1]) > sizeof(desc.ld_uuid) - 1) { fprintf(stderr, - "error: %s: LOV uuid '%s' longer than %d characters\n", + "error: %s: LOV uuid '%s' longer than %zd characters\n", cmdname(argv[0]), argv[1], sizeof(desc.ld_uuid) - 1); return -EINVAL; }