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/lustre_dlm.h>
  15
  16 static int ldlm_test_callback(struct ldlm_lock *lock, struct ldlm_lock *new,
  17                               void *data, __u32 data_len,
  18                               struct ptlrpc_request **reqp)
  19 {
  20         printk("ldlm_test_callback: lock=%p, new=%p\n", lock, new);
  21         return 0;
  22 }
  23
  24 int ldlm_test_basics(struct obd_device *obddev)
  25 {
  26         struct ldlm_namespace *ns;
  27         struct ldlm_resource *res;
  28         __u64 res_id[RES_NAME_SIZE] = {1, 2, 3};
  29         ldlm_error_t err;
  30         struct lustre_handle lockh_1, lockh_2;
  31         int flags;
  32
  33         ns = ldlm_namespace_new("test_server", LDLM_NAMESPACE_SERVER);
  34         if (ns == NULL)
  35                 LBUG();
  36
  37         err = ldlm_local_lock_create(ns, NULL, res_id, LDLM_PLAIN, LCK_CR,
  38                                      NULL, 0, &lockh_1);
  39         err = ldlm_local_lock_enqueue(&lockh_1, NULL, 0, &flags,
  40                                       ldlm_test_callback, ldlm_test_callback);
  41         if (err != ELDLM_OK)
  42                 LBUG();
  43
  44         err = ldlm_local_lock_create(ns, NULL, res_id, LDLM_PLAIN, LCK_EX,
  45                                      NULL, 0, &lockh_2);
  46         err = ldlm_local_lock_enqueue(&lockh_2, NULL, 0, &flags,
  47                                       ldlm_test_callback, ldlm_test_callback);
  48         if (err != ELDLM_OK)
  49                 LBUG();
  50         if (!(flags & LDLM_FL_BLOCK_GRANTED))
  51                 LBUG();
  52
  53         res = ldlm_resource_get(ns, NULL, res_id, LDLM_PLAIN, 1);
  54         if (res == NULL)
  55                 LBUG();
  56         ldlm_resource_dump(res);
  57
  58         res = ldlm_local_lock_convert(&lockh_1, LCK_NL, &flags);
  59         if (res != NULL)
  60                 ldlm_reprocess_all(res);
  61
  62         ldlm_resource_dump(res);
  63         ldlm_namespace_free(ns);
  64
  65         return 0;
  66 }
  67
  68 int ldlm_test_extents(struct obd_device *obddev)
  69 {
  70         struct ldlm_namespace *ns;
  71         struct ldlm_resource *res;
  72         struct ldlm_lock *lock;
  73         __u64 res_id[RES_NAME_SIZE] = {0, 0, 0};
  74         struct ldlm_extent ext1 = {4, 6}, ext2 = {6, 9}, ext3 = {10, 11};
  75         struct lustre_handle ext1_h, ext2_h, ext3_h;
  76         ldlm_error_t err;
  77         int flags;
  78
  79         ns = ldlm_namespace_new("test_server", LDLM_NAMESPACE_SERVER);
  80         if (ns == NULL)
  81                 LBUG();
  82
  83         flags = 0;
  84         err = ldlm_local_lock_create(ns, NULL, res_id, LDLM_EXTENT, LCK_PR,
  85                                      NULL, 0, &ext1_h);
  86         err = ldlm_local_lock_enqueue(&ext1_h, &ext1, sizeof(ext1), &flags,
  87                                       NULL, NULL);
  88         if (err != ELDLM_OK)
  89                 LBUG();
  90         if (!(flags & LDLM_FL_LOCK_CHANGED))
  91                 LBUG();
  92
  93         flags = 0;
  94         err = ldlm_local_lock_create(ns, NULL, res_id, LDLM_EXTENT, LCK_PR,
  95                                      NULL, 0, &ext2_h);
  96         err = ldlm_local_lock_enqueue(&ext2_h, &ext2, sizeof(ext2), &flags,
  97                                       NULL, NULL);
  98         if (err != ELDLM_OK)
  99                 LBUG();
 100         if (!(flags & LDLM_FL_LOCK_CHANGED))
 101                 LBUG();
 102
 103         flags = 0;
 104         err = ldlm_local_lock_create(ns, NULL, res_id, LDLM_EXTENT, LCK_EX,
 105                                      NULL, 0, &ext3_h);
 106         err = ldlm_local_lock_enqueue(&ext3_h, &ext3, sizeof(ext3), &flags,
 107                                       NULL, NULL);
 108         if (err != ELDLM_OK)
 109                 LBUG();
 110         if (!(flags & LDLM_FL_BLOCK_GRANTED))
 111                 LBUG();
 112         if (flags & LDLM_FL_LOCK_CHANGED)
 113                 LBUG();
 114
 115         /* Convert/cancel blocking locks */
 116         flags = 0;
 117         res = ldlm_local_lock_convert(&ext1_h, LCK_NL, &flags);
 118         if (res != NULL)
 119                 ldlm_reprocess_all(res);
 120
 121         flags = 0;
 122         lock = lustre_handle2object(&ext2_h);
 123         res = ldlm_local_lock_cancel(lock);
 124         if (res != NULL)
 125                 ldlm_reprocess_all(res);
 126
 127         /* Dump the results */
 128         res = ldlm_resource_get(ns, NULL, res_id, LDLM_EXTENT, 0);
 129         if (res == NULL)
 130                 LBUG();
 131         ldlm_resource_dump(res);
 132         ldlm_namespace_free(ns);
 133
 134         return 0;
 135 }
 136
 137 static int ldlm_test_network(struct obd_device *obddev,
 138                              struct ptlrpc_connection *conn)
 139 {
 140         struct ldlm_obd *ldlm = &obddev->u.ldlm;
 141
 142         __u64 res_id[RES_NAME_SIZE] = {1, 2, 3};
 143         struct ldlm_extent ext = {4, 6};
 144         struct lustre_handle lockh1;
 145         int flags = 0;
 146         ldlm_error_t err;
 147
 148         err = ldlm_cli_enqueue(ldlm->ldlm_client, conn, NULL,
 149                                obddev->obd_namespace, NULL, res_id, LDLM_EXTENT,
 150                                &ext, sizeof(ext), LCK_PR, &flags, NULL, NULL, 0,
 151                                &lockh1);
 152         CERROR("ldlm_cli_enqueue: %d\n", err);
 153
 154         RETURN(err);
 155 }
 156
 157 int ldlm_test(struct obd_device *obddev, struct ptlrpc_connection *conn)
 158 {
 159         int rc;
 160         rc = ldlm_test_basics(obddev);
 161         if (rc)
 162                 RETURN(rc);
 163
 164         rc = ldlm_test_extents(obddev);
 165         if (rc)
 166                 RETURN(rc);
 167
 168         rc = ldlm_test_network(obddev, conn);
 169         RETURN(rc);
 170 }