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         ldlm_lock();
  34
  35         err = ldlm_namespace_new(obddev, 1, &ns);
  36         if (err != ELDLM_OK)
  37                 LBUG();
  38
  39         err = ldlm_local_lock_create(1, NULL, res_id, LDLM_PLAIN, &lockh_1);
  40         err = ldlm_local_lock_enqueue(&lockh_1, LCK_CR, NULL, &flags, NULL,
  41                                       ldlm_test_callback, NULL, 0);
  42         if (err != ELDLM_OK)
  43                 LBUG();
  44
  45         err = ldlm_local_lock_create(1, NULL, res_id, LDLM_PLAIN, &lockh_2);
  46         err = ldlm_local_lock_enqueue(&lockh_2, LCK_EX, NULL, &flags, NULL,
  47                                       ldlm_test_callback, NULL, 0);
  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         err = ldlm_local_lock_convert(&lockh_1, LCK_NL, &flags);
  59         if (err != ELDLM_OK)
  60                 LBUG();
  61
  62         ldlm_resource_dump(res);
  63         ldlm_unlock();
  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         __u64 res_id[RES_NAME_SIZE] = {0, 0, 0};
  73         struct ldlm_extent ext1 = {4, 6}, ext2 = {6, 9}, ext3 = {10, 11};
  74         struct ldlm_handle ext1_h, ext2_h, ext3_h;
  75         ldlm_error_t err;
  76         int flags;
  77
  78         ldlm_lock();
  79
  80         err = ldlm_namespace_new(obddev, 2, &ns);
  81         if (err != ELDLM_OK)
  82                 LBUG();
  83
  84         flags = 0;
  85         err = ldlm_local_lock_create(2, NULL, res_id, LDLM_EXTENT, &ext1_h);
  86         err = ldlm_local_lock_enqueue(&ext1_h, LCK_PR, &ext1, &flags, NULL,
  87                                       NULL, NULL, 0);
  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(2, NULL, res_id, LDLM_EXTENT, &ext2_h);
  95         err = ldlm_local_lock_enqueue(&ext2_h, LCK_PR, &ext2, &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, &ext3_h);
 104         err = ldlm_local_lock_enqueue(&ext3_h, LCK_EX, &ext3, &flags, NULL,
 105                                       NULL, NULL, 0);
 106         if (err != ELDLM_OK)
 107                 LBUG();
 108         if (!(flags & LDLM_FL_BLOCK_GRANTED))
 109                 LBUG();
 110         if (flags & LDLM_FL_LOCK_CHANGED)
 111                 LBUG();
 112
 113         /* Convert/cancel blocking locks */
 114         flags = 0;
 115         err = ldlm_local_lock_convert(&ext1_h, LCK_NL, &flags);
 116         if (err != ELDLM_OK)
 117                 LBUG();
 118
 119         flags = 0;
 120         err = ldlm_local_lock_cancel(&ext2_h);
 121         if (err != ELDLM_OK)
 122                 LBUG();
 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
 130         ldlm_unlock();
 131
 132         return 0;
 133 }
 134
 135 static int ldlm_test_network(struct obd_device *obddev,
 136                              struct ptlrpc_connection *conn)
 137 {
 138         struct ldlm_obd *ldlm = &obddev->u.ldlm;
 139         struct ptlrpc_request *request;
 140
 141         __u64 res_id[RES_NAME_SIZE] = {1, 2, 3};
 142         struct ldlm_extent ext = {4, 6};
 143         struct ldlm_handle lockh1, lockh2;
 144         int flags = 0;
 145         ldlm_error_t err;
 146
 147         err = ldlm_cli_namespace_new(obddev, ldlm->ldlm_client, conn, 3);
 148         ptlrpc_free_req(request);
 149         CERROR("ldlm_cli_namespace_new: %d\n", err);
 150         if (err != ELDLM_OK)
 151                 GOTO(out, err);
 152
 153         err = ldlm_cli_enqueue(ldlm->ldlm_client, conn, 3,
 154                                NULL, res_id, LDLM_EXTENT, &ext, LCK_PR, &flags,
 155                                NULL, NULL, NULL, 0, &lockh1, &request);
 156         ptlrpc_free_req(request);
 157         CERROR("ldlm_cli_enqueue: %d\n", err);
 158
 159         flags = 0;
 160         err = ldlm_cli_enqueue(ldlm->ldlm_client, conn, 3,
 161                                NULL, res_id, LDLM_EXTENT, &ext, LCK_EX, &flags,
 162                                NULL, NULL, NULL, 0, &lockh2, &request);
 163         ptlrpc_free_req(request);
 164         CERROR("ldlm_cli_enqueue: %d\n", err);
 165
 166         EXIT;
 167  out:
 168         return err;
 169 }
 170
 171 int ldlm_test(struct obd_device *obddev, struct ptlrpc_connection *conn)
 172 {
 173         int rc;
 174         rc = ldlm_test_basics(obddev);
 175         if (rc)
 176                 RETURN(rc);
 177
 178         rc = ldlm_test_extents(obddev);
 179         if (rc)
 180                 RETURN(rc);
 181
 182         rc = ldlm_test_network(obddev, conn);
 183         RETURN(rc);
 184 }