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         err = ldlm_namespace_new(obddev, 1, &ns);
  45         if (err != ELDLM_OK)
  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         err = ldlm_local_lock_enqueue(obddev, 1, NULL, res_id, LDLM_PLAIN,
  54                                       NULL, LCK_CR, &flags, NULL,
  55                                       ldlm_test_callback, NULL, 0, &lockh_1);
  56         if (err != ELDLM_OK)
  57                 LBUG();
  58
  59         err = ldlm_local_lock_enqueue(obddev, 1, NULL, res_id, LDLM_PLAIN,
  60                                       NULL, LCK_EX, &flags, NULL,
  61                                       ldlm_test_callback, NULL, 0, &lockh_2);
  62         if (err != ELDLM_OK)
  63                 LBUG();
  64         if (!(flags & LDLM_FL_BLOCK_GRANTED))
  65                 LBUG();
  66
  67         ldlm_resource_dump(res);
  68
  69         err = ldlm_local_lock_convert(obddev, &lockh_1, LCK_NL, &flags);
  70         if (err != ELDLM_OK)
  71                 LBUG();
  72
  73         ldlm_resource_dump(res);
  74
  75         ldlm_unlock(obddev);
  76
  77         return 0;
  78 }
  79
  80 int ldlm_test_extents(struct obd_device *obddev)
  81 {
  82         struct ldlm_namespace *ns;
  83         struct ldlm_resource *res;
  84         __u64 res_id[RES_NAME_SIZE] = {0, 0, 0};
  85         struct ldlm_extent ext1 = {4, 6}, ext2 = {6, 9}, ext3 = {10, 11};
  86         struct ldlm_handle ext1_h, ext2_h, ext3_h;
  87         ldlm_error_t err;
  88         int flags;
  89
  90         ldlm_lock(obddev);
  91
  92         err = ldlm_namespace_new(obddev, 2, &ns);
  93         if (err != ELDLM_OK)
  94                 LBUG();
  95
  96         flags = 0;
  97         err = ldlm_local_lock_enqueue(obddev, 2, NULL, res_id, LDLM_EXTENT,
  98                                       &ext1, LCK_PR, &flags, NULL, NULL, NULL,
  99                                       0, &ext1_h);
 100         if (err != ELDLM_OK)
 101                 LBUG();
 102         if (!(flags & LDLM_FL_LOCK_CHANGED))
 103                 LBUG();
 104
 105         flags = 0;
 106         err = ldlm_local_lock_enqueue(obddev, 2, NULL, res_id, LDLM_EXTENT,
 107                                       &ext2, LCK_PR, &flags, NULL, NULL, NULL,
 108                                       0, &ext2_h);
 109         if (err != ELDLM_OK)
 110                 LBUG();
 111         if (!(flags & LDLM_FL_LOCK_CHANGED))
 112                 LBUG();
 113
 114         flags = 0;
 115         err = ldlm_local_lock_enqueue(obddev, 2, NULL, res_id, LDLM_EXTENT,
 116                                       &ext3, LCK_EX, &flags, NULL, NULL, NULL,
 117                                       0, &ext3_h);
 118         if (err != ELDLM_OK)
 119                 LBUG();
 120         if (!(flags & LDLM_FL_BLOCK_GRANTED))
 121                 LBUG();
 122         if (flags & LDLM_FL_LOCK_CHANGED)
 123                 LBUG();
 124
 125         /* Convert/cancel blocking locks */
 126         flags = 0;
 127         err = ldlm_local_lock_convert(obddev, &ext1_h, LCK_NL, &flags);
 128         if (err != ELDLM_OK)
 129                 LBUG();
 130
 131         flags = 0;
 132         err = ldlm_local_lock_cancel(obddev, &ext2_h);
 133         if (err != ELDLM_OK)
 134                 LBUG();
 135
 136         /* Dump the results */
 137         res = ldlm_resource_get(ns, NULL, res_id, LDLM_EXTENT, 0);
 138         if (res == NULL)
 139                 LBUG();
 140         ldlm_resource_dump(res);
 141
 142         ldlm_unlock(obddev);
 143
 144         return 0;
 145 }
 146
 147 static int ldlm_test_network(struct obd_device *obddev)
 148 {
 149         struct ldlm_obd *ldlm = &obddev->u.ldlm;
 150         struct ptlrpc_request *request;
 151
 152         __u64 res_id[RES_NAME_SIZE] = {1, 2, 3};
 153         struct ldlm_extent ext = {4, 6};
 154         struct ldlm_handle lockh1, lockh2;
 155         int flags = 0;
 156         ldlm_error_t err;
 157
 158         err = ldlm_cli_namespace_new(ldlm->ldlm_client, &ldlm->ldlm_server_peer,
 159                                      3, &request);
 160         ptlrpc_free_req(request);
 161         CERROR("ldlm_cli_namespace_new: %d\n", err);
 162         if (err != ELDLM_OK)
 163                 GOTO(out, err);
 164
 165         err = ldlm_cli_enqueue(ldlm->ldlm_client, &ldlm->ldlm_server_peer, 3,
 166                                NULL, res_id, LDLM_EXTENT, &ext, LCK_PR, &flags,
 167                                NULL, 0, &lockh1, &request);
 168         ptlrpc_free_req(request);
 169         CERROR("ldlm_cli_enqueue: %d\n", err);
 170
 171         flags = 0;
 172         err = ldlm_cli_enqueue(ldlm->ldlm_client, &ldlm->ldlm_server_peer, 3,
 173                                NULL, res_id, LDLM_EXTENT, &ext, LCK_EX, &flags,
 174                                NULL, 0, &lockh2, &request);
 175         ptlrpc_free_req(request);
 176         CERROR("ldlm_cli_enqueue: %d\n", err);
 177
 178         EXIT;
 179  out:
 180         return err;
 181 }
 182
 183 int ldlm_test(struct obd_device *obddev)
 184 {
 185         int rc;
 186         rc = ldlm_test_basics(obddev);
 187         if (rc)
 188                 RETURN(rc);
 189
 190         rc = ldlm_test_extents(obddev);
 191         if (rc)
 192                 RETURN(rc);
 193
 194         rc = ldlm_test_network(obddev);
 195         RETURN(rc);
 196 }