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 #define DEBUG_SUBSYSTEM S_LDLM
  14
  15 #include <linux/lustre_dlm.h>
  16
  17 static int ldlm_test_callback(struct ldlm_lock *lock, struct ldlm_lock *new,
  18                                void *data, __u32 data_len)
  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 ldlm_handle lockh_1, lockh_2;
  31         int flags;
  32
  33         ns = ldlm_namespace_new(obddev, 0);
  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, &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, &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 ldlm_handle ext1_h, ext2_h, ext3_h;
  76         ldlm_error_t err;
  77         int flags;
  78
  79         ns = ldlm_namespace_new(obddev, 0);
  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, &flags, 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, &flags, NULL, NULL);
  96         if (err != ELDLM_OK)
  97                 LBUG();
  98         if (!(flags & LDLM_FL_LOCK_CHANGED))
  99                 LBUG();
 100
 101         flags = 0;
 102         err = ldlm_local_lock_create(ns, NULL, res_id, LDLM_EXTENT, LCK_EX,
 103                                      NULL, 0, &ext3_h);
 104         err = ldlm_local_lock_enqueue(&ext3_h, &ext3, &flags, NULL, NULL);
 105         if (err != ELDLM_OK)
 106                 LBUG();
 107         if (!(flags & LDLM_FL_BLOCK_GRANTED))
 108                 LBUG();
 109         if (flags & LDLM_FL_LOCK_CHANGED)
 110                 LBUG();
 111
 112         /* Convert/cancel blocking locks */
 113         flags = 0;
 114         res = ldlm_local_lock_convert(&ext1_h, LCK_NL, &flags);
 115         if (res != NULL)
 116                 ldlm_reprocess_all(res);
 117
 118         flags = 0;
 119         lock = ldlm_handle2object(&ext2_h);
 120         res = ldlm_local_lock_cancel(lock);
 121         if (res != NULL)
 122                 ldlm_reprocess_all(res);
 123
 124         /* Dump the results */
 125         res = ldlm_resource_get(ns, NULL, res_id, LDLM_EXTENT, 0);
 126         if (res == NULL)
 127                 LBUG();
 128         ldlm_resource_dump(res);
 129         ldlm_namespace_free(ns);
 130
 131         return 0;
 132 }
 133
 134 static int ldlm_test_network(struct obd_device *obddev,
 135                              struct ptlrpc_connection *conn)
 136 {
 137         struct ldlm_obd *ldlm = &obddev->u.ldlm;
 138
 139         __u64 res_id[RES_NAME_SIZE] = {1, 2, 3};
 140         struct ldlm_extent ext = {4, 6};
 141         struct ldlm_handle lockh1;
 142         int flags = 0;
 143         ldlm_error_t err;
 144
 145         err = ldlm_cli_enqueue(ldlm->ldlm_client, conn, obddev->obd_namespace,
 146                                NULL, res_id, LDLM_EXTENT, &ext, LCK_PR, &flags,
 147                                NULL, 0, &lockh1);
 148         CERROR("ldlm_cli_enqueue: %d\n", err);
 149
 150         RETURN(err);
 151 }
 152
 153 int ldlm_test(struct obd_device *obddev, struct ptlrpc_connection *conn)
 154 {
 155         int rc;
 156         rc = ldlm_test_basics(obddev);
 157         if (rc)
 158                 RETURN(rc);
 159
 160         rc = ldlm_test_extents(obddev);
 161         if (rc)
 162                 RETURN(rc);
 163
 164         rc = ldlm_test_network(obddev, conn);
 165         RETURN(rc);
 166 }