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