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 EXPORT_SYMTAB
  13
  14 #include <linux/version.h>
  15 #include <linux/module.h>
  16 #include <linux/slab.h>
  17 #include <asm/unistd.h>
  18
  19 #define DEBUG_SUBSYSTEM S_LDLM
  20
  21 #include <linux/obd_support.h>
  22 #include <linux/obd_class.h>
  23
  24 #include <linux/lustre_dlm.h>
  25
  26 static int ldlm_test_callback(struct ldlm_lock *lock, struct ldlm_lock *new,
  27                                void *data, __u32 data_len)
  28 {
  29         printk("ldlm_test_callback: lock=%p, new=%p\n", lock, new);
  30         return 0;
  31 }
  32
  33 int ldlm_test_basics(struct obd_device *obddev)
  34 {
  35         struct ldlm_namespace *ns;
  36         struct ldlm_resource *res;
  37         __u64 res_id[RES_NAME_SIZE] = {1, 2, 3};
  38         ldlm_error_t err;
  39         struct ldlm_handle lockh_1, lockh_2;
  40         int flags;
  41
  42         ldlm_lock(obddev);
  43
  44         ns = ldlm_namespace_new(obddev, 1);
  45         if (ns == NULL)
  46                 LBUG();
  47
  48         res = ldlm_resource_get(ns, NULL, res_id, LDLM_PLAIN, 1);
  49         if (res == NULL)
  50                 LBUG();
  51
  52         /* Get a couple of read locks */
  53         flags = LDLM_FL_BLOCKING_AST;
  54         err = ldlm_local_lock_enqueue(obddev, 1, NULL, res_id, LDLM_PLAIN,
  55                                       NULL, LCK_CR, &flags, NULL,
  56                                       ldlm_test_callback, NULL, 0, &lockh_1);
  57         if (err != ELDLM_OK)
  58                 LBUG();
  59
  60         err = ldlm_local_lock_enqueue(obddev, 1, NULL, res_id, LDLM_PLAIN,
  61                                       NULL, LCK_EX, &flags, NULL,
  62                                       ldlm_test_callback, NULL, 0, &lockh_2);
  63         if (err != -ELDLM_BLOCK_GRANTED)
  64                 LBUG();
  65
  66         ldlm_resource_dump(res);
  67
  68         err = ldlm_local_lock_convert(obddev, &lockh_1, LCK_NL, &flags);
  69         if (err != ELDLM_OK)
  70                 LBUG();
  71
  72         ldlm_resource_dump(res);
  73
  74         ldlm_unlock(obddev);
  75
  76         return 0;
  77 }
  78
  79 int ldlm_test_extents(struct obd_device *obddev)
  80 {
  81         struct ldlm_namespace *ns;
  82         struct ldlm_resource *res;
  83         __u64 res_id[RES_NAME_SIZE] = {0, 0, 0};
  84         struct ldlm_extent ext1 = {4, 6}, ext2 = {6, 9}, ext3 = {10, 11};
  85         struct ldlm_handle ext1_h, ext2_h, ext3_h;
  86         ldlm_error_t err;
  87         int flags;
  88
  89         ldlm_lock(obddev);
  90
  91         ns = ldlm_namespace_new(obddev, 2);
  92         if (ns == NULL)
  93                 LBUG();
  94
  95         flags = 0;
  96         err = ldlm_local_lock_enqueue(obddev, 2, NULL, res_id, LDLM_EXTENT,
  97                                       &ext1, LCK_PR, &flags, NULL, NULL, NULL,
  98                                       0, &ext1_h);
  99         if (err != ELDLM_OK)
 100                 LBUG();
 101         if (!(flags & LDLM_FL_LOCK_CHANGED))
 102                 LBUG();
 103
 104         flags = 0;
 105         err = ldlm_local_lock_enqueue(obddev, 2, NULL, res_id, LDLM_EXTENT,
 106                                       &ext2, LCK_PR, &flags, NULL, NULL, NULL,
 107                                       0, &ext2_h);
 108         if (err != ELDLM_OK)
 109                 LBUG();
 110         if (!(flags & LDLM_FL_LOCK_CHANGED))
 111                 LBUG();
 112
 113         flags = 0;
 114         err = ldlm_local_lock_enqueue(obddev, 2, NULL, res_id, LDLM_EXTENT,
 115                                       &ext3, LCK_EX, &flags, NULL, NULL, NULL,
 116                                       0, &ext3_h);
 117         if (err != -ELDLM_BLOCK_GRANTED)
 118                 LBUG();
 119         if (flags & LDLM_FL_LOCK_CHANGED)
 120                 LBUG();
 121
 122         /* Convert/cancel blocking locks */
 123         flags = 0;
 124         err = ldlm_local_lock_convert(obddev, &ext1_h, LCK_NL, &flags);
 125         if (err != ELDLM_OK)
 126                 LBUG();
 127
 128         flags = 0;
 129         err = ldlm_local_lock_cancel(obddev, &ext2_h);
 130         if (err != ELDLM_OK)
 131                 LBUG();
 132
 133         /* Dump the results */
 134         res = ldlm_resource_get(ns, NULL, res_id, LDLM_EXTENT, 0);
 135         if (res == NULL)
 136                 LBUG();
 137         ldlm_resource_dump(res);
 138
 139         ldlm_unlock(obddev);
 140
 141         return 0;
 142 }
 143
 144 int ldlm_test(struct obd_device *obddev)
 145 {
 146         int rc;
 147         rc = ldlm_test_basics(obddev);
 148         if (rc)
 149                 RETURN(rc);
 150
 151         rc = ldlm_test_extents(obddev);
 152         RETURN(rc);
 153 }