lustre/ldlm/ldlm_test.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * Copyright (C) 2002 Cluster File Systems, Inc.
   5  *
   6  * This code is issued under the GNU General Public License.
   7  * See the file COPYING in this distribution
   8  *
   9  * by Cluster File Systems, Inc.
  10  */
  11
  12 #define DEBUG_SUBSYSTEM S_LDLM
  13
  14 #include <linux/types.h>
  15 #include <linux/random.h>
  16
  17 #include <linux/lustre_dlm.h>
  18
  19 struct ldlm_test_thread {
  20         struct ldlm_namespace *t_ns;
  21         struct list_head t_link;
  22         __u32 t_flags;
  23         wait_queue_head_t t_ctl_waitq;
  24 };
  25
  26 static spinlock_t ctl_lock = SPIN_LOCK_UNLOCKED;
  27 static struct list_head ctl_threads;
  28 static int regression_running = 0;
  29 static struct ptlrpc_client ctl_client;
  30 static struct ptlrpc_connection *ctl_conn;
  31
  32 static int ldlm_test_callback(struct lustre_handle *lockh,
  33                               struct ldlm_lock_desc *new,
  34                               void *data, __u32 data_len)
  35 {
  36         struct ldlm_lock *lock;
  37         ENTRY;
  38
  39         lock = ldlm_handle2lock(lockh);
  40         if (lock == NULL) {
  41                 CERROR("invalid handle in callback\n");
  42                 RETURN(0);
  43         }
  44
  45         printk("ldlm_test_callback: lock=%Lu, new=%p\n", lockh->addr, new);
  46         return 0;
  47 }
  48
  49 int ldlm_test_basics(struct obd_device *obddev)
  50 {
  51         struct ldlm_namespace *ns;
  52         struct ldlm_resource *res;
  53         __u64 res_id[RES_NAME_SIZE] = {1, 2, 3};
  54         ldlm_error_t err;
  55         struct ldlm_lock *lock1, *lock;
  56         int flags;
  57
  58         ns = ldlm_namespace_new("test_server", LDLM_NAMESPACE_SERVER);
  59         if (ns == NULL)
  60                 LBUG();
  61
  62         lock1 = ldlm_lock_create(ns, NULL, res_id, LDLM_PLAIN, LCK_CR, NULL, 0);
  63         if (lock1 == NULL)
  64                 LBUG();
  65         err = ldlm_lock_enqueue(lock1, NULL, 0, &flags,
  66                                 ldlm_test_callback, ldlm_test_callback);
  67         if (err != ELDLM_OK)
  68                 LBUG();
  69
  70         lock = ldlm_lock_create(ns, NULL, res_id, LDLM_PLAIN, LCK_EX, NULL, 0);
  71         if (lock == NULL)
  72                 LBUG();
  73         err = ldlm_lock_enqueue(lock, NULL, 0, &flags,
  74                                 ldlm_test_callback, ldlm_test_callback);
  75         if (err != ELDLM_OK)
  76                 LBUG();
  77         if (!(flags & LDLM_FL_BLOCK_GRANTED))
  78                 LBUG();
  79
  80         res = ldlm_resource_get(ns, NULL, res_id, LDLM_PLAIN, 1);
  81         if (res == NULL)
  82                 LBUG();
  83         ldlm_resource_dump(res);
  84
  85         res = ldlm_lock_convert(lock1, LCK_NL, &flags);
  86         if (res != NULL)
  87                 ldlm_reprocess_all(res);
  88
  89         ldlm_resource_dump(res);
  90         ldlm_namespace_free(ns);
  91
  92         return 0;
  93 }
  94
  95 int ldlm_test_extents(struct obd_device *obddev)
  96 {
  97         struct ldlm_namespace *ns;
  98         struct ldlm_resource *res;
  99         struct ldlm_lock *lock, *lock1, *lock2;
 100         __u64 res_id[RES_NAME_SIZE] = {0, 0, 0};
 101         struct ldlm_extent ext1 = {4, 6}, ext2 = {6, 9}, ext3 = {10, 11};
 102         ldlm_error_t err;
 103         int flags;
 104
 105         ns = ldlm_namespace_new("test_server", LDLM_NAMESPACE_SERVER);
 106         if (ns == NULL)
 107                 LBUG();
 108
 109         flags = 0;
 110         lock1 = ldlm_lock_create(ns, NULL, res_id, LDLM_EXTENT, LCK_PR, NULL,
 111                                  0);
 112         if (lock1 == NULL)
 113                 LBUG();
 114         err = ldlm_lock_enqueue(lock1, &ext1, sizeof(ext1), &flags, NULL, NULL);
 115         if (err != ELDLM_OK)
 116                 LBUG();
 117         if (!(flags & LDLM_FL_LOCK_CHANGED))
 118                 LBUG();
 119
 120         flags = 0;
 121         lock2 = ldlm_lock_create(ns, NULL, res_id, LDLM_EXTENT, LCK_PR,
 122                                 NULL, 0);
 123         err = ldlm_lock_enqueue(lock2, &ext2, sizeof(ext2), &flags, NULL, NULL);
 124         if (err != ELDLM_OK)
 125                 LBUG();
 126         if (!(flags & LDLM_FL_LOCK_CHANGED))
 127                 LBUG();
 128
 129         flags = 0;
 130         lock = ldlm_lock_create(ns, NULL, res_id, LDLM_EXTENT, LCK_EX, NULL, 0);
 131         if (lock == NULL)
 132                 LBUG();
 133         err = ldlm_lock_enqueue(lock, &ext3, sizeof(ext3), &flags,
 134                                 NULL, NULL);
 135         if (err != ELDLM_OK)
 136                 LBUG();
 137         if (!(flags & LDLM_FL_BLOCK_GRANTED))
 138                 LBUG();
 139         if (flags & LDLM_FL_LOCK_CHANGED)
 140                 LBUG();
 141
 142         /* Convert/cancel blocking locks */
 143         flags = 0;
 144         res = ldlm_lock_convert(lock1, LCK_NL, &flags);
 145         if (res != NULL)
 146                 ldlm_reprocess_all(res);
 147
 148         ldlm_lock_cancel(lock2);
 149         if (res != NULL)
 150                 ldlm_reprocess_all(res);
 151
 152         /* Dump the results */
 153         res = ldlm_resource_get(ns, NULL, res_id, LDLM_EXTENT, 0);
 154         if (res == NULL)
 155                 LBUG();
 156         ldlm_resource_dump(res);
 157         ldlm_namespace_free(ns);
 158
 159         return 0;
 160 }
 161
 162 static int ldlm_test_network(struct obd_device *obddev,
 163                              struct ptlrpc_connection *conn)
 164 {
 165         struct ldlm_obd *ldlm = &obddev->u.ldlm;
 166
 167         __u64 res_id[RES_NAME_SIZE] = {1, 2, 3};
 168         struct ldlm_extent ext = {4, 6};
 169         struct lustre_handle lockh1;
 170         int flags = 0;
 171         ldlm_error_t err;
 172
 173         err = ldlm_cli_enqueue(ldlm->ldlm_client, conn, NULL,
 174                                obddev->obd_namespace, NULL, res_id, LDLM_EXTENT,
 175                                &ext, sizeof(ext), LCK_PR, &flags, NULL, NULL, 0,
 176                                &lockh1);
 177         CERROR("ldlm_cli_enqueue: %d\n", err);
 178
 179         RETURN(err);
 180 }
 181
 182 static int ldlm_test_main(void *data)
 183 {
 184         struct ldlm_test_thread *thread = data;
 185         struct ldlm_namespace *ns;
 186         ENTRY;
 187
 188         lock_kernel();
 189         daemonize();
 190         spin_lock_irq(&current->sigmask_lock);
 191         sigfillset(&current->blocked);
 192         recalc_sigpending(current);
 193         spin_unlock_irq(&current->sigmask_lock);
 194
 195         sprintf(current->comm, "ldlm_test");
 196
 197         ns = ldlm_namespace_new("ldlm_test", LDLM_NAMESPACE_CLIENT);
 198         if (ns == NULL) {
 199                 LBUG();
 200                 GOTO(out, -ENOMEM);
 201         }
 202
 203         /* Record that the thread is running */
 204         thread->t_flags |= SVC_RUNNING;
 205         wake_up(&thread->t_ctl_waitq);
 206
 207         while (1) {
 208                 struct lustre_handle lockh;
 209                 __u64 res_id[3] = {0};
 210                 __u32 lock_mode;
 211                 char random;
 212                 int flags = 0, rc;
 213
 214                 /* Pick a random resource from 1 to 10 */
 215                 get_random_bytes(&random, sizeof(random));
 216                 res_id[0] = random % 10 + 1;
 217
 218                 /* Pick a random lock mode */
 219                 get_random_bytes(&random, sizeof(random));
 220                 lock_mode = random % LCK_NL + 1;
 221
 222                 rc = ldlm_cli_enqueue(&ctl_client, ctl_conn, NULL, ns, NULL,
 223                                       res_id, LDLM_PLAIN, NULL, 0, lock_mode,
 224                                       &flags, ldlm_test_callback, NULL, 0,
 225                                       &lockh);
 226                 if (rc < 0) {
 227                         CERROR("ldlm_cli_enqueue: %d\n", rc);
 228                         LBUG();
 229                 }
 230         }
 231
 232  out:
 233         thread->t_flags |= SVC_STOPPED;
 234         wake_up(&thread->t_ctl_waitq);
 235
 236         RETURN(0);
 237 }
 238
 239 static int ldlm_start_thread(void)
 240 {
 241         struct ldlm_test_thread *test;
 242         int rc;
 243         ENTRY;
 244
 245         OBD_ALLOC(test, sizeof(*test));
 246         if (test == NULL) {
 247                 LBUG();
 248                 RETURN(-ENOMEM);
 249         }
 250         init_waitqueue_head(&test->t_ctl_waitq);
 251
 252         spin_lock(&ctl_lock);
 253         list_add(&test->t_link, &ctl_threads);
 254         spin_unlock(&ctl_lock);
 255
 256         rc = kernel_thread(ldlm_test_main, (void *)test,
 257                            CLONE_VM | CLONE_FS | CLONE_FILES);
 258         if (rc < 0) {
 259                 CERROR("cannot start thread\n");
 260                 RETURN(-EINVAL);
 261         }
 262         wait_event(test->t_ctl_waitq, test->t_flags & SVC_RUNNING);
 263
 264         RETURN(0);
 265 }
 266
 267 int ldlm_regression_start(struct obd_device *obddev,
 268                           struct ptlrpc_connection *conn, int count)
 269 {
 270         int i, rc = 0;
 271         ENTRY;
 272
 273         spin_lock(&ctl_lock);
 274         if (regression_running) {
 275                 CERROR("You can't start the ldlm regression twice.\n");
 276                 spin_unlock(&ctl_lock);
 277                 RETURN(-EINVAL);
 278         }
 279         regression_running = 1;
 280         spin_unlock(&ctl_lock);
 281
 282         for (i = 0; i < count; i++) {
 283                 rc = ldlm_start_thread();
 284                 if (rc < 0)
 285                         GOTO(cleanup, rc);
 286         }
 287
 288  cleanup:
 289         RETURN(rc);
 290 }
 291
 292 int ldlm_regression_stop(void)
 293 {
 294         ENTRY;
 295
 296         spin_lock(&ctl_lock);
 297         if (!regression_running) {
 298                 CERROR("The ldlm regression isn't started.\n");
 299                 spin_unlock(&ctl_lock);
 300                 RETURN(-EINVAL);
 301         }
 302
 303         while (!list_empty(&ctl_threads)) {
 304                 struct ldlm_test_thread *thread;
 305                 thread = list_entry(ctl_threads.next, struct ldlm_test_thread,
 306                                     t_link);
 307
 308                 thread->t_flags |= SVC_STOPPING;
 309                 spin_unlock(&ctl_lock);
 310
 311                 wake_up(&thread->t_ctl_waitq);
 312                 wait_event_interruptible(thread->t_ctl_waitq,
 313                                          thread->t_flags & SVC_STOPPED);
 314
 315                 spin_lock(&ctl_lock);
 316                 list_del(&thread->t_link);
 317                 OBD_FREE(thread, sizeof(*thread));
 318         }
 319
 320         regression_running = 0;
 321         spin_unlock(&ctl_lock);
 322
 323         RETURN(0);
 324 }
 325
 326 int ldlm_test(struct obd_device *obddev, struct ptlrpc_connection *conn)
 327 {
 328         int rc;
 329         rc = ldlm_test_basics(obddev);
 330         if (rc)
 331                 RETURN(rc);
 332
 333         rc = ldlm_test_extents(obddev);
 334         if (rc)
 335                 RETURN(rc);
 336
 337         rc = ldlm_test_network(obddev, conn);
 338         RETURN(rc);
 339 }