#include <linux/random.h>
#include <linux/lustre_dlm.h>
+#include <linux/obd.h>
struct ldlm_test_thread {
struct obd_device *obddev;
*/
static int ldlm_test_blocking_ast(struct ldlm_lock *lock,
struct ldlm_lock_desc *new,
- void *data, __u32 data_len)
+ void *data, int flag)
{
int rc;
struct lustre_handle lockh;
ENTRY;
- LDLM_DEBUG(lock, "We're blocking. Cancelling lock");
- ldlm_lock2handle(lock, &lockh);
- rc = ldlm_cli_cancel(&lockh);
- if (rc < 0) {
- CERROR("ldlm_cli_cancel: %d\n", rc);
+ switch (flag) {
+ case LDLM_CB_BLOCKING:
+ LDLM_DEBUG(lock, "We're blocking. Cancelling lock");
+ ldlm_lock2handle(lock, &lockh);
+ rc = ldlm_cli_cancel(&lockh);
+ if (rc < 0) {
+ CERROR("ldlm_cli_cancel: %d\n", rc);
+ LBUG();
+ }
+ break;
+ case LDLM_CB_CANCELING:
+ LDLM_DEBUG(lock, "this lock is being cancelled");
+ break;
+ default:
LBUG();
}
/* blocking ast for basic tests. noop */
static int ldlm_blocking_ast(struct ldlm_lock *lock,
struct ldlm_lock_desc *new,
- void *data, __u32 data_len)
+ void *data, int flag)
{
ENTRY;
- CERROR("ldlm_blocking_ast: lock=%p, new=%p\n", lock, new);
+ CERROR("ldlm_blocking_ast: lock=%p, new=%p, flag=%d\n", lock, new,
+ flag);
RETURN(0);
}
/* Completion ast for regression test.
* Does not sleep when blocked.
*/
-static int ldlm_test_completion_ast(struct ldlm_lock *lock, int flags)
+static int ldlm_test_completion_ast(struct ldlm_lock *lock, int flags, void *data)
{
struct ldlm_test_lock *lock_info;
ENTRY;
if (flags & (LDLM_FL_BLOCK_WAIT | LDLM_FL_BLOCK_GRANTED |
- LDLM_FL_BLOCK_CONV)) {
-
+ LDLM_FL_BLOCK_CONV)) {
LDLM_DEBUG(lock, "client-side enqueue returned a blocked lock");
RETURN(0);
- }
+ }
- if (lock->l_granted_mode != lock->l_req_mode)
+ if (lock->l_granted_mode != lock->l_req_mode)
CERROR("completion ast called with non-granted lock\n");
/* add to list of granted locks */
{
struct ldlm_namespace *ns;
struct ldlm_resource *res;
- __u64 res_id[RES_NAME_SIZE] = {1, 2, 3};
+ struct ldlm_res_id res_id = { .name = {1, 2, 3} };
ldlm_error_t err;
struct ldlm_lock *lock1, *lock;
int flags;
lock1 = ldlm_lock_create(ns, NULL, res_id, LDLM_PLAIN, LCK_CR, NULL, 0);
if (lock1 == NULL)
LBUG();
- err = ldlm_lock_enqueue(lock1, NULL, 0, &flags,
+ err = ldlm_lock_enqueue(ns, lock1, NULL, 0, &flags,
ldlm_completion_ast, ldlm_blocking_ast);
if (err != ELDLM_OK)
LBUG();
lock = ldlm_lock_create(ns, NULL, res_id, LDLM_PLAIN, LCK_EX, NULL, 0);
if (lock == NULL)
LBUG();
- err = ldlm_lock_enqueue(lock, NULL, 0, &flags,
+ err = ldlm_lock_enqueue(ns, lock, NULL, 0, &flags,
ldlm_completion_ast, ldlm_blocking_ast);
if (err != ELDLM_OK)
LBUG();
ldlm_reprocess_all(res);
ldlm_resource_dump(res);
- ldlm_namespace_free(ns);
+ ldlm_namespace_free(ns, 0);
RETURN(0);
}
struct ldlm_namespace *ns;
struct ldlm_resource *res;
struct ldlm_lock *lock, *lock1, *lock2;
- __u64 res_id[RES_NAME_SIZE] = {0, 0, 0};
+ struct ldlm_res_id res_id = { .name = {0} };
struct ldlm_extent ext1 = {4, 6}, ext2 = {6, 9}, ext3 = {10, 11};
ldlm_error_t err;
int flags;
LBUG();
flags = 0;
- lock1 = ldlm_lock_create(ns, NULL, res_id, LDLM_EXTENT, LCK_PR, NULL,
- 0);
+ lock1 = ldlm_lock_create(ns, NULL, res_id, LDLM_EXTENT, LCK_PR, NULL,0);
if (lock1 == NULL)
LBUG();
- err = ldlm_lock_enqueue(lock1, &ext1, sizeof(ext1), &flags, NULL, NULL);
+ err = ldlm_lock_enqueue(ns, lock1, &ext1, sizeof(ext1), &flags, NULL,
+ NULL);
if (err != ELDLM_OK)
LBUG();
if (!(flags & LDLM_FL_LOCK_CHANGED))
LBUG();
flags = 0;
- lock2 = ldlm_lock_create(ns, NULL, res_id, LDLM_EXTENT, LCK_PR,
- NULL, 0);
- err = ldlm_lock_enqueue(lock2, &ext2, sizeof(ext2), &flags, NULL, NULL);
+ lock2 = ldlm_lock_create(ns, NULL, res_id, LDLM_EXTENT, LCK_PR, NULL,0);
+ err = ldlm_lock_enqueue(ns, lock2, &ext2, sizeof(ext2), &flags, NULL,
+ NULL);
if (err != ELDLM_OK)
LBUG();
if (!(flags & LDLM_FL_LOCK_CHANGED))
lock = ldlm_lock_create(ns, NULL, res_id, LDLM_EXTENT, LCK_EX, NULL, 0);
if (lock == NULL)
LBUG();
- err = ldlm_lock_enqueue(lock, &ext3, sizeof(ext3), &flags,
+ err = ldlm_lock_enqueue(ns, lock, &ext3, sizeof(ext3), &flags,
NULL, NULL);
if (err != ELDLM_OK)
LBUG();
if (res == NULL)
LBUG();
ldlm_resource_dump(res);
- ldlm_namespace_free(ns);
+ ldlm_namespace_free(ns, 0);
RETURN(0);
}
static int ldlm_test_network(struct obd_device *obddev,
struct lustre_handle *connh)
{
-
- __u64 res_id[RES_NAME_SIZE] = {1, 2, 3};
+ struct ldlm_res_id res_id = { .name = {1, 2, 3} };
struct ldlm_extent ext = {4, 6};
struct lustre_handle lockh1;
struct ldlm_lock *lock;
CERROR("ldlm_cli_convert: %d\n", err);
lock = ldlm_handle2lock(&lockh1);
- ldlm_lock_dump(lock);
+ ldlm_lock_dump(D_OTHER, lock);
ldlm_lock_put(lock);
/* Need to decrement old mode. Don't bother incrementing new
struct ldlm_lock *lock;
int rc = 0;
ENTRY;
-
+
spin_lock(&ctl_lock);
if(list_empty(&lock_list)) {
CERROR("lock_list is empty\n");
spin_unlock(&ctl_lock);
- RETURN(0);
- }
-
+ RETURN(0);
+ }
+
/* delete from list */
- lock_info = list_entry(lock_list.next,
+ lock_info = list_entry(lock_list.next,
struct ldlm_test_lock, l_link);
list_del(lock_list.next);
num_locks--;
spin_unlock(&ctl_lock);
-
+
/* decrement and free the info */
lock = ldlm_handle2lock(&lock_info->l_lockh);
ldlm_lock_decref(&lock_info->l_lockh, lock->l_granted_mode);
}
static int ldlm_do_enqueue(struct ldlm_test_thread *thread)
-{
+{
struct lustre_handle lockh;
- __u64 res_id[3] = {0};
+ struct ldlm_res_id res_id = { .name = {0} };
__u32 lock_mode;
struct ldlm_extent ext;
unsigned char random;
/* Pick a random resource from 1 to num_resources */
get_random_bytes(&random, sizeof(random));
- res_id[0] = random % num_resources;
+ res_id.name[0] = random % num_resources;
/* Pick a random lock mode */
get_random_bytes(&random, sizeof(random));
get_random_bytes(&random, sizeof(random));
ext.start = random % num_extents;
get_random_bytes(&random, sizeof(random));
- ext.end = random %
+ ext.end = random %
(num_extents - (int)ext.start) + ext.start;
- LDLM_DEBUG_NOLOCK("about to enqueue with resource %d, mode %d,"
- " extent %d -> %d",
- (int)res_id[0],
- lock_mode,
- (int)ext.start,
- (int)ext.end);
-
- rc = ldlm_match_or_enqueue(®ress_connh,
- NULL,
- thread->obddev->obd_namespace,
- NULL, res_id, LDLM_EXTENT, &ext,
- sizeof(ext), lock_mode, &flags,
- ldlm_test_completion_ast,
- ldlm_test_blocking_ast,
+ LDLM_DEBUG_NOLOCK("about to enqueue with resource "LPX64", mode %d,"
+ " extent "LPX64" -> "LPX64, res_id.name[0], lock_mode,
+ ext.start, ext.end);
+
+ rc = ldlm_match_or_enqueue(®ress_connh, NULL,
+ thread->obddev->obd_namespace,
+ NULL, res_id, LDLM_EXTENT, &ext,
+ sizeof(ext), lock_mode, &flags,
+ ldlm_test_completion_ast,
+ ldlm_test_blocking_ast,
NULL, 0, &lockh);
atomic_inc(&locks_requested);
}
static int ldlm_do_convert(void)
-{
+{
__u32 lock_mode;
unsigned char random;
int flags = 0, rc = 0;
}
/*
- * Adjust reference counts.
+ * Adjust reference counts.
* FIXME: This is technically a bit... wrong,
* since we don't know when/if the convert succeeded
*/
static int ldlm_test_main(void *data)
{
struct ldlm_test_thread *thread = data;
+ unsigned long flags;
ENTRY;
lock_kernel();
daemonize();
- spin_lock_irq(¤t->sigmask_lock);
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
+ sigfillset(¤t->blocked);
+ recalc_sigpending();
+#else
+ spin_lock_irqsave(¤t->sigmask_lock, flags);
sigfillset(¤t->blocked);
recalc_sigpending(current);
- spin_unlock_irq(¤t->sigmask_lock);
+ spin_unlock_irqrestore(¤t->sigmask_lock, flags);
+#endif
sprintf(current->comm, "ldlm_test");
unlock_kernel();
*/
dec_chance = chance_left * num_locks / max_locks;
chance_left -= dec_chance;
-
+
/* FIXME: conversions temporarily disabled
* until they are working correctly.
*/
atomic_read(&locks_matched));
spin_lock(&ctl_lock);
- LDLM_DEBUG_NOLOCK("lock references currently held: %d, ",
+ LDLM_DEBUG_NOLOCK("lock references currently held: %d, ",
num_locks);
spin_unlock(&ctl_lock);
- /*
+ /*
* We don't sleep after a lock being blocked, so let's
* make sure other things can run.
*/
RETURN(0);
}
-int ldlm_regression_start(struct obd_device *obddev,
- struct lustre_handle *connh,
- unsigned int threads, unsigned int max_locks_in,
- unsigned int num_resources_in,
+int ldlm_regression_start(struct obd_device *obddev,
+ struct lustre_handle *connh,
+ unsigned int threads, unsigned int max_locks_in,
+ unsigned int num_resources_in,
unsigned int num_extents_in)
{
int i, rc = 0;
regression_running = 1;
spin_unlock(&ctl_lock);
- regress_connh = *connh;
+ regress_connh = *connh;
max_locks = max_locks_in;
num_resources = num_resources_in;
num_extents = num_extents_in;
/* decrement all held locks */
while (!list_empty(&lock_list)) {
struct ldlm_lock *lock;
- struct ldlm_test_lock *lock_info =
- list_entry(lock_list.next, struct ldlm_test_lock,
+ struct ldlm_test_lock *lock_info =
+ list_entry(lock_list.next, struct ldlm_test_lock,
l_link);
list_del(lock_list.next);
num_locks--;
git://git.whamcloud.com / fs / lustre-release.git / blobdiff