lustre/ldlm/ldlm_lockd.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  *   Author: Peter Braam <braam@clusterfs.com>
   6  *   Author: Phil Schwan <phil@clusterfs.com>
   7  *
   8  *   This file is part of Lustre, http://www.lustre.org.
   9  *
  10  *   Lustre is free software; you can redistribute it and/or
  11  *   modify it under the terms of version 2 of the GNU General Public
  12  *   License as published by the Free Software Foundation.
  13  *
  14  *   Lustre is distributed in the hope that it will be useful,
  15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *   GNU General Public License for more details.
  18  *
  19  *   You should have received a copy of the GNU General Public License
  20  *   along with Lustre; if not, write to the Free Software
  21  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24 #define EXPORT_SYMTAB
  25 #define DEBUG_SUBSYSTEM S_LDLM
  26
  27 #include <linux/module.h>
  28 #include <linux/slab.h>
  29 #include <linux/lustre_dlm.h>
  30 #include <linux/init.h>
  31
  32 extern kmem_cache_t *ldlm_resource_slab;
  33 extern kmem_cache_t *ldlm_lock_slab;
  34 extern struct list_head ldlm_namespace_list;
  35 extern int (*mds_reint_p)(int offset, struct ptlrpc_request *req);
  36 extern int (*mds_getattr_name_p)(int offset, struct ptlrpc_request *req);
  37
  38 static int ldlm_server_blocking_ast(struct ldlm_lock *lock,
  39                                     struct ldlm_lock_desc *desc,
  40                                     void *data, __u32 data_len)
  41 {
  42         struct ldlm_request *body;
  43         struct ptlrpc_request *req;
  44         struct ptlrpc_client *cl;
  45         int rc = 0, size = sizeof(*body);
  46         ENTRY;
  47
  48         cl = &lock->l_resource->lr_namespace->ns_rpc_client;
  49         req = ptlrpc_prep_req(cl, lock->l_connection, LDLM_BL_CALLBACK, 1,
  50                               &size, NULL);
  51         if (!req)
  52                 RETURN(-ENOMEM);
  53
  54         body = lustre_msg_buf(req->rq_reqmsg, 0);
  55         memcpy(&body->lock_handle1, &lock->l_remote_handle,
  56                sizeof(body->lock_handle1));
  57         memcpy(&body->lock_desc, desc, sizeof(*desc));
  58
  59         LDLM_DEBUG(lock, "server preparing blocking AST");
  60         req->rq_replen = lustre_msg_size(0, NULL);
  61
  62         rc = ptlrpc_queue_wait(req);
  63         rc = ptlrpc_check_status(req, rc);
  64         ptlrpc_free_req(req);
  65
  66         RETURN(rc);
  67 }
  68
  69 static int ldlm_server_completion_ast(struct ldlm_lock *lock, int flags)
  70 {
  71         struct ldlm_request *body;
  72         struct ptlrpc_request *req;
  73         struct ptlrpc_client *cl;
  74         int rc = 0, size = sizeof(*body);
  75         ENTRY;
  76
  77         if (lock == NULL) {
  78                 LBUG();
  79                 RETURN(-EINVAL);
  80         }
  81
  82         cl = &lock->l_resource->lr_namespace->ns_rpc_client;
  83         req = ptlrpc_prep_req(cl, lock->l_connection, LDLM_CP_CALLBACK, 1,
  84                               &size, NULL);
  85         if (!req)
  86                 RETURN(-ENOMEM);
  87
  88         body = lustre_msg_buf(req->rq_reqmsg, 0);
  89         memcpy(&body->lock_handle1, &lock->l_remote_handle,
  90                sizeof(body->lock_handle1));
  91         body->lock_flags = flags;
  92         ldlm_lock2desc(lock, &body->lock_desc);
  93
  94         LDLM_DEBUG(lock, "server preparing completion AST");
  95         req->rq_replen = lustre_msg_size(0, NULL);
  96
  97         rc = ptlrpc_queue_wait(req);
  98         rc = ptlrpc_check_status(req, rc);
  99         ptlrpc_free_req(req);
 100         RETURN(rc);
 101 }
 102
 103 int ldlm_handle_enqueue(struct ptlrpc_request *req)
 104 {
 105         struct obd_device *obddev = req->rq_export->exp_obd;
 106         struct ldlm_reply *dlm_rep;
 107         struct ldlm_request *dlm_req;
 108         int rc, size = sizeof(*dlm_rep), cookielen = 0;
 109         __u32 flags;
 110         ldlm_error_t err;
 111         struct ldlm_lock *lock = NULL;
 112         void *cookie = NULL;
 113         ENTRY;
 114
 115         LDLM_DEBUG_NOLOCK("server-side enqueue handler START");
 116
 117         dlm_req = lustre_msg_buf(req->rq_reqmsg, 0);
 118         if (dlm_req->lock_desc.l_resource.lr_type == LDLM_MDSINTENT) {
 119                 /* In this case, the reply buffer is allocated deep in
 120                  * local_lock_enqueue by the policy function. */
 121                 cookie = req;
 122                 cookielen = sizeof(*req);
 123         } else {
 124                 rc = lustre_pack_msg(1, &size, NULL, &req->rq_replen,
 125                                      &req->rq_repmsg);
 126                 if (rc) {
 127                         CERROR("out of memory\n");
 128                         RETURN(-ENOMEM);
 129                 }
 130                 if (dlm_req->lock_desc.l_resource.lr_type == LDLM_EXTENT) {
 131                         cookie = &dlm_req->lock_desc.l_extent;
 132                         cookielen = sizeof(struct ldlm_extent);
 133                 }
 134         }
 135
 136         lock = ldlm_lock_create(obddev->obd_namespace,
 137                                 &dlm_req->lock_handle2,
 138                                 dlm_req->lock_desc.l_resource.lr_name,
 139                                 dlm_req->lock_desc.l_resource.lr_type,
 140                                 dlm_req->lock_desc.l_req_mode, NULL, 0);
 141         if (!lock)
 142                 GOTO(out, err = -ENOMEM);
 143
 144         memcpy(&lock->l_remote_handle, &dlm_req->lock_handle1,
 145                sizeof(lock->l_remote_handle));
 146         LDLM_DEBUG(lock, "server-side enqueue handler, new lock created");
 147
 148         flags = dlm_req->lock_flags;
 149         err = ldlm_lock_enqueue(lock, cookie, cookielen, &flags,
 150                                 ldlm_server_completion_ast,
 151                                 ldlm_server_blocking_ast);
 152         if (err != ELDLM_OK)
 153                 GOTO(out, err);
 154
 155         dlm_rep = lustre_msg_buf(req->rq_repmsg, 0);
 156         dlm_rep->lock_flags = flags;
 157
 158         ldlm_lock2handle(lock, &dlm_rep->lock_handle);
 159         if (dlm_req->lock_desc.l_resource.lr_type == LDLM_EXTENT)
 160                 memcpy(&dlm_rep->lock_extent, &lock->l_extent,
 161                        sizeof(lock->l_extent));
 162         if (dlm_rep->lock_flags & LDLM_FL_LOCK_CHANGED) {
 163                 memcpy(dlm_rep->lock_resource_name, lock->l_resource->lr_name,
 164                        sizeof(dlm_rep->lock_resource_name));
 165                 dlm_rep->lock_mode = lock->l_req_mode;
 166         }
 167
 168         lock->l_connection = ptlrpc_connection_addref(req->rq_connection);
 169         EXIT;
 170  out:
 171         if (lock)
 172                 LDLM_DEBUG(lock, "server-side enqueue handler, sending reply"
 173                            "(err=%d)", err);
 174         req->rq_status = err;
 175
 176         if (ptlrpc_reply(req->rq_svc, req))
 177                 LBUG();
 178
 179         if (lock) {
 180                 if (!err)
 181                         ldlm_reprocess_all(lock->l_resource);
 182                 LDLM_LOCK_PUT(lock);
 183         }
 184         LDLM_DEBUG_NOLOCK("server-side enqueue handler END (lock %p)", lock);
 185
 186         return 0;
 187 }
 188
 189 int ldlm_handle_convert(struct ptlrpc_request *req)
 190 {
 191         struct ldlm_request *dlm_req;
 192         struct ldlm_reply *dlm_rep;
 193         struct ldlm_lock *lock;
 194         int rc, size = sizeof(*dlm_rep);
 195         ENTRY;
 196
 197         rc = lustre_pack_msg(1, &size, NULL, &req->rq_replen, &req->rq_repmsg);
 198         if (rc) {
 199                 CERROR("out of memory\n");
 200                 RETURN(-ENOMEM);
 201         }
 202         dlm_req = lustre_msg_buf(req->rq_reqmsg, 0);
 203         dlm_rep = lustre_msg_buf(req->rq_repmsg, 0);
 204         dlm_rep->lock_flags = dlm_req->lock_flags;
 205
 206         lock = ldlm_handle2lock(&dlm_req->lock_handle1);
 207         if (!lock) {
 208                 req->rq_status = EINVAL;
 209         } else {
 210                 LDLM_DEBUG(lock, "server-side convert handler START");
 211                 ldlm_lock_convert(lock, dlm_req->lock_desc.l_req_mode,
 212                                   &dlm_rep->lock_flags);
 213                 req->rq_status = 0;
 214         }
 215         if (ptlrpc_reply(req->rq_svc, req) != 0)
 216                 LBUG();
 217
 218         if (lock) {
 219                 ldlm_reprocess_all(lock->l_resource);
 220                 LDLM_DEBUG(lock, "server-side convert handler END");
 221                 LDLM_LOCK_PUT(lock);
 222         } else
 223                 LDLM_DEBUG_NOLOCK("server-side convert handler END");
 224
 225         RETURN(0);
 226 }
 227
 228 int ldlm_handle_cancel(struct ptlrpc_request *req)
 229 {
 230         struct ldlm_request *dlm_req;
 231         struct ldlm_lock *lock;
 232         int rc;
 233         ENTRY;
 234
 235         rc = lustre_pack_msg(0, NULL, NULL, &req->rq_replen, &req->rq_repmsg);
 236         if (rc) {
 237                 CERROR("out of memory\n");
 238                 RETURN(-ENOMEM);
 239         }
 240         dlm_req = lustre_msg_buf(req->rq_reqmsg, 0);
 241
 242         lock = ldlm_handle2lock(&dlm_req->lock_handle1);
 243         if (!lock) {
 244                 LDLM_DEBUG_NOLOCK("server-side cancel handler stale lock (lock "
 245                                   "%p)", (void *)(unsigned long)
 246                                   dlm_req->lock_handle1.addr);
 247                 req->rq_status = ESTALE;
 248         } else {
 249                 LDLM_DEBUG(lock, "server-side cancel handler START");
 250                 ldlm_lock_cancel(lock);
 251                 req->rq_status = 0;
 252         }
 253
 254         if (ptlrpc_reply(req->rq_svc, req) != 0)
 255                 LBUG();
 256
 257         if (lock) {
 258                 ldlm_reprocess_all(lock->l_resource);
 259                 LDLM_DEBUG(lock, "server-side cancel handler END");
 260                 LDLM_LOCK_PUT(lock);
 261         }
 262
 263         RETURN(0);
 264 }
 265
 266 static int ldlm_handle_bl_callback(struct ptlrpc_request *req)
 267 {
 268         struct ldlm_request *dlm_req;
 269         struct ldlm_lock *lock;
 270         int rc, do_ast;
 271         ENTRY;
 272
 273         rc = lustre_pack_msg(0, NULL, NULL, &req->rq_replen, &req->rq_repmsg);
 274         if (rc)
 275                 RETURN(-ENOMEM);
 276         rc = ptlrpc_reply(req->rq_svc, req);
 277         if (rc)
 278                 RETURN(rc);
 279
 280         dlm_req = lustre_msg_buf(req->rq_reqmsg, 0);
 281
 282         lock = ldlm_handle2lock(&dlm_req->lock_handle1);
 283         if (!lock) {
 284                 CERROR("blocking callback on lock %Lx - lock disappeared\n",
 285                        dlm_req->lock_handle1.addr);
 286                 RETURN(0);
 287         }
 288
 289         LDLM_DEBUG(lock, "client blocking AST callback handler START");
 290
 291         l_lock(&lock->l_resource->lr_namespace->ns_lock);
 292         lock->l_flags |= LDLM_FL_CBPENDING;
 293         do_ast = (!lock->l_readers && !lock->l_writers);
 294         l_unlock(&lock->l_resource->lr_namespace->ns_lock);
 295
 296         if (do_ast) {
 297                 LDLM_DEBUG(lock, "already unused, calling "
 298                            "callback (%p)", lock->l_blocking_ast);
 299                 if (lock->l_blocking_ast != NULL) {
 300                         lock->l_blocking_ast(lock, &dlm_req->lock_desc,
 301                                              lock->l_data, lock->l_data_len);
 302                 }
 303         } else
 304                 LDLM_DEBUG(lock, "Lock still has references, will be"
 305                            " cancelled later");
 306
 307         LDLM_DEBUG(lock, "client blocking callback handler END");
 308         LDLM_LOCK_PUT(lock);
 309         RETURN(0);
 310 }
 311
 312 static int ldlm_handle_cp_callback(struct ptlrpc_request *req)
 313 {
 314         struct list_head ast_list = LIST_HEAD_INIT(ast_list);
 315         struct ldlm_request *dlm_req;
 316         struct ldlm_lock *lock;
 317         int rc;
 318         ENTRY;
 319
 320         rc = lustre_pack_msg(0, NULL, NULL, &req->rq_replen, &req->rq_repmsg);
 321         if (rc)
 322                 RETURN(-ENOMEM);
 323         rc = ptlrpc_reply(req->rq_svc, req);
 324         if (rc)
 325                 RETURN(rc);
 326
 327         dlm_req = lustre_msg_buf(req->rq_reqmsg, 0);
 328
 329         lock = ldlm_handle2lock(&dlm_req->lock_handle1);
 330         if (!lock) {
 331                 CERROR("completion callback on lock %Lx - lock disappeared\n",
 332                        dlm_req->lock_handle1.addr);
 333                 RETURN(0);
 334         }
 335
 336         LDLM_DEBUG(lock, "client completion callback handler START");
 337
 338         l_lock(&lock->l_resource->lr_namespace->ns_lock);
 339
 340         /* If we receive the completion AST before the actual enqueue returned,
 341          * then we might need to switch resources or lock modes. */
 342         if (dlm_req->lock_desc.l_granted_mode != lock->l_req_mode) {
 343                 lock->l_req_mode = dlm_req->lock_desc.l_granted_mode;
 344                 LDLM_DEBUG(lock, "completion AST, new lock mode");
 345         }
 346         ldlm_resource_unlink_lock(lock);
 347         if (memcmp(dlm_req->lock_desc.l_resource.lr_name,
 348                    lock->l_resource->lr_name,
 349                    sizeof(__u64) * RES_NAME_SIZE) != 0) {
 350                 ldlm_lock_change_resource(lock, dlm_req->lock_desc.l_resource.lr_name);
 351                 LDLM_DEBUG(lock, "completion AST, new resource");
 352         }
 353         lock->l_resource->lr_tmp = &ast_list;
 354         ldlm_grant_lock(lock);
 355         lock->l_resource->lr_tmp = NULL;
 356         l_unlock(&lock->l_resource->lr_namespace->ns_lock);
 357         LDLM_DEBUG(lock, "callback handler finished, about to run_ast_work");
 358         LDLM_LOCK_PUT(lock);
 359
 360         ldlm_run_ast_work(&ast_list);
 361
 362         LDLM_DEBUG_NOLOCK("client completion callback handler END (lock %p)",
 363                           lock);
 364         RETURN(0);
 365 }
 366
 367 static int ldlm_callback_handler(struct ptlrpc_request *req)
 368 {
 369         int rc;
 370         ENTRY;
 371
 372         rc = lustre_unpack_msg(req->rq_reqmsg, req->rq_reqlen);
 373         if (rc) {
 374                 CERROR("lustre_ldlm: Invalid request\n");
 375                 GOTO(out, rc);
 376         }
 377
 378         if (req->rq_reqmsg->type != PTL_RPC_MSG_REQUEST) {
 379                 CERROR("lustre_ldlm: wrong packet type sent %d\n",
 380                        req->rq_reqmsg->type);
 381                 GOTO(out, rc = -EINVAL);
 382         }
 383         switch (req->rq_reqmsg->opc) {
 384         case LDLM_BL_CALLBACK:
 385                 CDEBUG(D_INODE, "blocking ast\n");
 386                 OBD_FAIL_RETURN(OBD_FAIL_LDLM_BL_CALLBACK, 0);
 387                 rc = ldlm_handle_bl_callback(req);
 388                 break;
 389         case LDLM_CP_CALLBACK:
 390                 CDEBUG(D_INODE, "completion ast\n");
 391                 OBD_FAIL_RETURN(OBD_FAIL_LDLM_CP_CALLBACK, 0);
 392                 rc = ldlm_handle_cp_callback(req);
 393                 break;
 394
 395         default:
 396                 rc = ptlrpc_error(req->rq_svc, req);
 397                 RETURN(rc);
 398         }
 399
 400         EXIT;
 401 out:
 402         if (rc)
 403                 RETURN(ptlrpc_error(req->rq_svc, req));
 404         return 0;
 405 }
 406
 407
 408 static int ldlm_iocontrol(long cmd, struct lustre_handle *conn, int len,
 409                           void *karg, void *uarg)
 410 {
 411         struct obd_device *obddev = class_conn2obd(conn);
 412         struct ptlrpc_connection *connection;
 413         int err = 0;
 414         ENTRY;
 415
 416         if (_IOC_TYPE(cmd) != IOC_LDLM_TYPE || _IOC_NR(cmd) < IOC_LDLM_MIN_NR ||
 417             _IOC_NR(cmd) > IOC_LDLM_MAX_NR) {
 418                 CDEBUG(D_IOCTL, "invalid ioctl (type %ld, nr %ld, size %ld)\n",
 419                        _IOC_TYPE(cmd), _IOC_NR(cmd), _IOC_SIZE(cmd));
 420                 RETURN(-EINVAL);
 421         }
 422
 423         OBD_ALLOC(obddev->u.ldlm.ldlm_client,
 424                   sizeof(*obddev->u.ldlm.ldlm_client));
 425         ptlrpc_init_client(NULL, NULL,
 426                            LDLM_REQUEST_PORTAL, LDLM_REPLY_PORTAL,
 427                            obddev->u.ldlm.ldlm_client);
 428         connection = ptlrpc_uuid_to_connection("ldlm");
 429         if (!connection)
 430                 CERROR("No LDLM UUID found: assuming ldlm is local.\n");
 431
 432         switch (cmd) {
 433         case IOC_LDLM_TEST:
 434                 err = ldlm_test(obddev, conn);
 435                 CERROR("-- done err %d\n", err);
 436                 GOTO(out, err);
 437         case IOC_LDLM_DUMP:
 438                 ldlm_dump_all_namespaces();
 439                 GOTO(out, err);
 440         default:
 441                 GOTO(out, err = -EINVAL);
 442         }
 443
 444  out:
 445         if (connection)
 446                 ptlrpc_put_connection(connection);
 447         OBD_FREE(obddev->u.ldlm.ldlm_client,
 448                  sizeof(*obddev->u.ldlm.ldlm_client));
 449         return err;
 450 }
 451
 452 #define LDLM_NUM_THREADS        8
 453
 454 static int ldlm_setup(struct obd_device *obddev, obd_count len, void *buf)
 455 {
 456         struct ldlm_obd *ldlm = &obddev->u.ldlm;
 457         int rc, i;
 458         ENTRY;
 459
 460         MOD_INC_USE_COUNT;
 461         rc = ldlm_proc_setup(obddev);
 462         if (rc != 0)
 463                 GOTO(out_dec, rc);
 464
 465         ldlm->ldlm_service = ptlrpc_init_svc(64 * 1024, LDLM_REQUEST_PORTAL,
 466                                              LDLM_REPLY_PORTAL, "self",
 467                                              ldlm_callback_handler);
 468         if (!ldlm->ldlm_service)
 469                 GOTO(out_proc, rc = -ENOMEM);
 470
 471         for (i = 0; i < LDLM_NUM_THREADS; i++) {
 472                 char name[32];
 473                 sprintf(name, "lustre_dlm_%02d", i);
 474                 rc = ptlrpc_start_thread(obddev, ldlm->ldlm_service, name);
 475                 if (rc) {
 476                         CERROR("cannot start LDLM thread #%d: rc %d\n", i, rc);
 477                         LBUG();
 478                         GOTO(out_thread, rc);
 479                 }
 480         }
 481
 482         RETURN(0);
 483
 484  out_thread:
 485         ptlrpc_stop_all_threads(ldlm->ldlm_service);
 486         ptlrpc_unregister_service(ldlm->ldlm_service);
 487  out_proc:
 488         ldlm_proc_cleanup(obddev);
 489  out_dec:
 490         MOD_DEC_USE_COUNT;
 491         return rc;
 492 }
 493
 494 static int ldlm_cleanup(struct obd_device *obddev)
 495 {
 496         struct ldlm_obd *ldlm = &obddev->u.ldlm;
 497         ENTRY;
 498
 499         if (!list_empty(&ldlm_namespace_list)) {
 500                 CERROR("ldlm still has namespaces; clean these up first.\n");
 501                 RETURN(-EBUSY);
 502         }
 503
 504         ptlrpc_stop_all_threads(ldlm->ldlm_service);
 505         ptlrpc_unregister_service(ldlm->ldlm_service);
 506         ldlm_proc_cleanup(obddev);
 507
 508         MOD_DEC_USE_COUNT;
 509         RETURN(0);
 510 }
 511
 512 struct obd_ops ldlm_obd_ops = {
 513         o_iocontrol:   ldlm_iocontrol,
 514         o_setup:       ldlm_setup,
 515         o_cleanup:     ldlm_cleanup,
 516         o_connect:     class_connect,
 517         o_disconnect:  class_disconnect
 518 };
 519
 520 static int __init ldlm_init(void)
 521 {
 522         int rc = class_register_type(&ldlm_obd_ops, OBD_LDLM_DEVICENAME);
 523         if (rc != 0)
 524                 return rc;
 525
 526         ldlm_resource_slab = kmem_cache_create("ldlm_resources",
 527                                                sizeof(struct ldlm_resource), 0,
 528                                                SLAB_HWCACHE_ALIGN, NULL, NULL);
 529         if (ldlm_resource_slab == NULL)
 530                 return -ENOMEM;
 531
 532         ldlm_lock_slab = kmem_cache_create("ldlm_locks",
 533                                            sizeof(struct ldlm_lock), 0,
 534                                            SLAB_HWCACHE_ALIGN, NULL, NULL);
 535         if (ldlm_lock_slab == NULL) {
 536                 kmem_cache_destroy(ldlm_resource_slab);
 537                 return -ENOMEM;
 538         }
 539
 540         return 0;
 541 }
 542
 543 static void __exit ldlm_exit(void)
 544 {
 545         class_unregister_type(OBD_LDLM_DEVICENAME);
 546         if (kmem_cache_destroy(ldlm_resource_slab) != 0)
 547                 CERROR("couldn't free ldlm resource slab\n");
 548         if (kmem_cache_destroy(ldlm_lock_slab) != 0)
 549                 CERROR("couldn't free ldlm lock slab\n");
 550 }
 551
 552 EXPORT_SYMBOL(ldlm_completion_ast);
 553 EXPORT_SYMBOL(ldlm_handle_enqueue);
 554 EXPORT_SYMBOL(ldlm_handle_cancel);
 555 EXPORT_SYMBOL(ldlm_handle_convert);
 556 EXPORT_SYMBOL(ldlm_register_intent);
 557 EXPORT_SYMBOL(ldlm_unregister_intent);
 558 EXPORT_SYMBOL(ldlm_lockname);
 559 EXPORT_SYMBOL(ldlm_typename);
 560 EXPORT_SYMBOL(ldlm_handle2lock);
 561 EXPORT_SYMBOL(ldlm_lock2handle);
 562 EXPORT_SYMBOL(ldlm_lock_put);
 563 EXPORT_SYMBOL(ldlm_lock_match);
 564 EXPORT_SYMBOL(ldlm_lock_addref);
 565 EXPORT_SYMBOL(ldlm_lock_decref);
 566 EXPORT_SYMBOL(ldlm_lock_change_resource);
 567 EXPORT_SYMBOL(ldlm_cli_convert);
 568 EXPORT_SYMBOL(ldlm_cli_enqueue);
 569 EXPORT_SYMBOL(ldlm_cli_cancel);
 570 EXPORT_SYMBOL(ldlm_match_or_enqueue);
 571 EXPORT_SYMBOL(ldlm_it2str);
 572 EXPORT_SYMBOL(ldlm_test);
 573 EXPORT_SYMBOL(ldlm_regression_start);
 574 EXPORT_SYMBOL(ldlm_regression_stop);
 575 EXPORT_SYMBOL(ldlm_lock_dump);
 576 EXPORT_SYMBOL(ldlm_namespace_new);
 577 EXPORT_SYMBOL(ldlm_namespace_free);
 578 EXPORT_SYMBOL(l_lock);
 579 EXPORT_SYMBOL(l_unlock);
 580
 581 MODULE_AUTHOR("Cluster File Systems, Inc. <info@clusterfs.com>");
 582 MODULE_DESCRIPTION("Lustre Lock Management Module v0.1");
 583 MODULE_LICENSE("GPL");
 584
 585 module_init(ldlm_init);
 586 module_exit(ldlm_exit);