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, 4, 3};
  38         ldlm_error_t err;
  39         struct ldlm_handle h;
  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                                       LCK_CR, &flags, NULL, ldlm_test_callback,
  56                                       NULL, 0, &h);
  57         if (err != ELDLM_OK)
  58                 LBUG();
  59
  60         err = ldlm_local_lock_enqueue(obddev, 1, NULL, res_id, LDLM_PLAIN,
  61                                       LCK_EX, &flags, NULL, ldlm_test_callback,
  62                                       NULL, 0, &h);
  63         if (err != -ELDLM_BLOCK_GRANTED)
  64                 LBUG();
  65
  66         ldlm_resource_dump(res);
  67
  68         ldlm_unlock(obddev);
  69
  70         return 0;
  71 }
  72
  73 int ldlm_test_extents(struct obd_device *obddev)
  74 {
  75         struct ldlm_namespace *ns;
  76         struct ldlm_resource *res;
  77         __u64 file_res_id[RES_NAME_SIZE] = {0, 0, 0};
  78         __u64 res_ext1[RES_NAME_SIZE] = {4, 6, 3};
  79         __u64 res_ext2[RES_NAME_SIZE] = {6, 9, 3};
  80         __u64 res_ext3[RES_NAME_SIZE] = {10, 11, 3};
  81         ldlm_error_t err;
  82         struct ldlm_handle file_h, ext1_h, ext2_h, ext3_h;
  83         int flags;
  84
  85         ldlm_lock(obddev);
  86
  87         ns = ldlm_namespace_new(obddev, 2);
  88         if (ns == NULL)
  89                 LBUG();
  90
  91         err = ldlm_local_lock_enqueue(obddev, 1, NULL, file_res_id, LDLM_EXTENT,
  92                                       LCK_NL, &flags, NULL, NULL, NULL, 0,
  93                                       &file_h);
  94         if (err != ELDLM_OK)
  95                 LBUG();
  96
  97         flags = 0;
  98         err = ldlm_local_lock_enqueue(obddev, 1, &file_h, res_ext1, LDLM_EXTENT,
  99                                       LCK_PR, &flags, NULL, NULL, NULL, 0,
 100                                       &ext1_h);
 101         if (err != ELDLM_OK)
 102                 LBUG();
 103         if (!(flags & LDLM_FL_RES_CHANGED))
 104                 LBUG();
 105
 106         flags = 0;
 107         err = ldlm_local_lock_enqueue(obddev, 1, &file_h, res_ext2, LDLM_EXTENT,
 108                                       LCK_PR, &flags, NULL, NULL, NULL, 0,
 109                                       &ext2_h);
 110         if (err != ELDLM_OK)
 111                 LBUG();
 112         if (!(flags & LDLM_FL_RES_CHANGED))
 113                 LBUG();
 114
 115         flags = 0;
 116         err = ldlm_local_lock_enqueue(obddev, 1, &file_h, res_ext3, LDLM_EXTENT,
 117                                       LCK_EX, &flags, NULL, NULL, NULL, 0,
 118                                       &ext3_h);
 119         if (err != -ELDLM_BLOCK_GRANTED)
 120                 LBUG();
 121         if (flags & LDLM_FL_RES_CHANGED)
 122                 LBUG();
 123
 124         /* Convert/cancel blocking locks */
 125         flags = 0;
 126         err = ldlm_local_lock_convert(obddev, &ext1_h, LCK_NL, &flags);
 127         if (err != ELDLM_OK)
 128                 LBUG();
 129
 130         flags = 0;
 131         err = ldlm_local_lock_cancel(obddev, &ext1_h);
 132         if (err != ELDLM_OK)
 133                 LBUG();
 134
 135         /* Dump the results */
 136         res = ldlm_resource_get(ns, NULL, file_res_id, LDLM_EXTENT, 0);
 137         if (res == NULL)
 138                 LBUG();
 139         ldlm_resource_dump(res);
 140         res = ldlm_resource_get(ns, NULL, res_ext1, LDLM_EXTENT, 0);
 141         if (res == NULL)
 142                 LBUG();
 143         ldlm_resource_dump(res);
 144         res = ldlm_resource_get(ns, NULL, res_ext2, LDLM_EXTENT, 0);
 145         if (res == NULL)
 146                 LBUG();
 147         ldlm_resource_dump(res);
 148
 149         ldlm_unlock(obddev);
 150
 151         return 0;
 152 }
 153
 154 int ldlm_test(struct obd_device *obddev)
 155 {
 156         int rc;
 157         rc = ldlm_test_basics(obddev);
 158         if (rc)
 159                 RETURN(rc);
 160
 161         rc = ldlm_test_extents(obddev);
 162         RETURN(rc);
 163 }