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