Merge master.kernel.org:/pub/scm/linux/kernel/git/kyle/parisc-2.6
[linux-2.6] / fs / ocfs2 / dlm / userdlm.c
1 /* -*- mode: c; c-basic-offset: 8; -*-
2  * vim: noexpandtab sw=8 ts=8 sts=0:
3  *
4  * userdlm.c
5  *
6  * Code which implements the kernel side of a minimal userspace
7  * interface to our DLM.
8  *
9  * Many of the functions here are pared down versions of dlmglue.c
10  * functions.
11  *
12  * Copyright (C) 2003, 2004 Oracle.  All rights reserved.
13  *
14  * This program is free software; you can redistribute it and/or
15  * modify it under the terms of the GNU General Public
16  * License as published by the Free Software Foundation; either
17  * version 2 of the License, or (at your option) any later version.
18  *
19  * This program is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
22  * General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public
25  * License along with this program; if not, write to the
26  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
27  * Boston, MA 021110-1307, USA.
28  */
29
30 #include <linux/signal.h>
31
32 #include <linux/module.h>
33 #include <linux/fs.h>
34 #include <linux/types.h>
35 #include <linux/crc32.h>
36
37
38 #include "cluster/nodemanager.h"
39 #include "cluster/heartbeat.h"
40 #include "cluster/tcp.h"
41
42 #include "dlmapi.h"
43
44 #include "userdlm.h"
45
46 #define MLOG_MASK_PREFIX ML_DLMFS
47 #include "cluster/masklog.h"
48
49 static inline int user_check_wait_flag(struct user_lock_res *lockres,
50                                        int flag)
51 {
52         int ret;
53
54         spin_lock(&lockres->l_lock);
55         ret = lockres->l_flags & flag;
56         spin_unlock(&lockres->l_lock);
57
58         return ret;
59 }
60
61 static inline void user_wait_on_busy_lock(struct user_lock_res *lockres)
62
63 {
64         wait_event(lockres->l_event,
65                    !user_check_wait_flag(lockres, USER_LOCK_BUSY));
66 }
67
68 static inline void user_wait_on_blocked_lock(struct user_lock_res *lockres)
69
70 {
71         wait_event(lockres->l_event,
72                    !user_check_wait_flag(lockres, USER_LOCK_BLOCKED));
73 }
74
75 /* I heart container_of... */
76 static inline struct dlm_ctxt *
77 dlm_ctxt_from_user_lockres(struct user_lock_res *lockres)
78 {
79         struct dlmfs_inode_private *ip;
80
81         ip = container_of(lockres,
82                           struct dlmfs_inode_private,
83                           ip_lockres);
84         return ip->ip_dlm;
85 }
86
87 static struct inode *
88 user_dlm_inode_from_user_lockres(struct user_lock_res *lockres)
89 {
90         struct dlmfs_inode_private *ip;
91
92         ip = container_of(lockres,
93                           struct dlmfs_inode_private,
94                           ip_lockres);
95         return &ip->ip_vfs_inode;
96 }
97
98 static inline void user_recover_from_dlm_error(struct user_lock_res *lockres)
99 {
100         spin_lock(&lockres->l_lock);
101         lockres->l_flags &= ~USER_LOCK_BUSY;
102         spin_unlock(&lockres->l_lock);
103 }
104
105 #define user_log_dlm_error(_func, _stat, _lockres) do {         \
106         mlog(ML_ERROR, "Dlm error \"%s\" while calling %s on "  \
107                 "resource %s: %s\n", dlm_errname(_stat), _func, \
108                 _lockres->l_name, dlm_errmsg(_stat));           \
109 } while (0)
110
111 /* WARNING: This function lives in a world where the only three lock
112  * levels are EX, PR, and NL. It *will* have to be adjusted when more
113  * lock types are added. */
114 static inline int user_highest_compat_lock_level(int level)
115 {
116         int new_level = LKM_EXMODE;
117
118         if (level == LKM_EXMODE)
119                 new_level = LKM_NLMODE;
120         else if (level == LKM_PRMODE)
121                 new_level = LKM_PRMODE;
122         return new_level;
123 }
124
125 static void user_ast(void *opaque)
126 {
127         struct user_lock_res *lockres = opaque;
128         struct dlm_lockstatus *lksb;
129
130         mlog(0, "AST fired for lockres %s\n", lockres->l_name);
131
132         spin_lock(&lockres->l_lock);
133
134         lksb = &(lockres->l_lksb);
135         if (lksb->status != DLM_NORMAL) {
136                 mlog(ML_ERROR, "lksb status value of %u on lockres %s\n",
137                      lksb->status, lockres->l_name);
138                 spin_unlock(&lockres->l_lock);
139                 return;
140         }
141
142         mlog_bug_on_msg(lockres->l_requested == LKM_IVMODE,
143                         "Lockres %s, requested ivmode. flags 0x%x\n",
144                         lockres->l_name, lockres->l_flags);
145
146         /* we're downconverting. */
147         if (lockres->l_requested < lockres->l_level) {
148                 if (lockres->l_requested <=
149                     user_highest_compat_lock_level(lockres->l_blocking)) {
150                         lockres->l_blocking = LKM_NLMODE;
151                         lockres->l_flags &= ~USER_LOCK_BLOCKED;
152                 }
153         }
154
155         lockres->l_level = lockres->l_requested;
156         lockres->l_requested = LKM_IVMODE;
157         lockres->l_flags |= USER_LOCK_ATTACHED;
158         lockres->l_flags &= ~USER_LOCK_BUSY;
159
160         spin_unlock(&lockres->l_lock);
161
162         wake_up(&lockres->l_event);
163 }
164
165 static inline void user_dlm_grab_inode_ref(struct user_lock_res *lockres)
166 {
167         struct inode *inode;
168         inode = user_dlm_inode_from_user_lockres(lockres);
169         if (!igrab(inode))
170                 BUG();
171 }
172
173 static void user_dlm_unblock_lock(void *opaque);
174
175 static void __user_dlm_queue_lockres(struct user_lock_res *lockres)
176 {
177         if (!(lockres->l_flags & USER_LOCK_QUEUED)) {
178                 user_dlm_grab_inode_ref(lockres);
179
180                 INIT_WORK(&lockres->l_work, user_dlm_unblock_lock,
181                           lockres);
182
183                 queue_work(user_dlm_worker, &lockres->l_work);
184                 lockres->l_flags |= USER_LOCK_QUEUED;
185         }
186 }
187
188 static void __user_dlm_cond_queue_lockres(struct user_lock_res *lockres)
189 {
190         int queue = 0;
191
192         if (!(lockres->l_flags & USER_LOCK_BLOCKED))
193                 return;
194
195         switch (lockres->l_blocking) {
196         case LKM_EXMODE:
197                 if (!lockres->l_ex_holders && !lockres->l_ro_holders)
198                         queue = 1;
199                 break;
200         case LKM_PRMODE:
201                 if (!lockres->l_ex_holders)
202                         queue = 1;
203                 break;
204         default:
205                 BUG();
206         }
207
208         if (queue)
209                 __user_dlm_queue_lockres(lockres);
210 }
211
212 static void user_bast(void *opaque, int level)
213 {
214         struct user_lock_res *lockres = opaque;
215
216         mlog(0, "Blocking AST fired for lockres %s. Blocking level %d\n",
217                 lockres->l_name, level);
218
219         spin_lock(&lockres->l_lock);
220         lockres->l_flags |= USER_LOCK_BLOCKED;
221         if (level > lockres->l_blocking)
222                 lockres->l_blocking = level;
223
224         __user_dlm_queue_lockres(lockres);
225         spin_unlock(&lockres->l_lock);
226
227         wake_up(&lockres->l_event);
228 }
229
230 static void user_unlock_ast(void *opaque, enum dlm_status status)
231 {
232         struct user_lock_res *lockres = opaque;
233
234         mlog(0, "UNLOCK AST called on lock %s\n", lockres->l_name);
235
236         if (status != DLM_NORMAL && status != DLM_CANCELGRANT)
237                 mlog(ML_ERROR, "Dlm returns status %d\n", status);
238
239         spin_lock(&lockres->l_lock);
240         /* The teardown flag gets set early during the unlock process,
241          * so test the cancel flag to make sure that this ast isn't
242          * for a concurrent cancel. */
243         if (lockres->l_flags & USER_LOCK_IN_TEARDOWN
244             && !(lockres->l_flags & USER_LOCK_IN_CANCEL)) {
245                 lockres->l_level = LKM_IVMODE;
246         } else if (status == DLM_CANCELGRANT) {
247                 mlog(0, "Lock %s, cancel fails, flags 0x%x\n",
248                      lockres->l_name, lockres->l_flags);
249                 /* We tried to cancel a convert request, but it was
250                  * already granted. Don't clear the busy flag - the
251                  * ast should've done this already. */
252                 BUG_ON(!(lockres->l_flags & USER_LOCK_IN_CANCEL));
253                 lockres->l_flags &= ~USER_LOCK_IN_CANCEL;
254                 goto out_noclear;
255         } else {
256                 BUG_ON(!(lockres->l_flags & USER_LOCK_IN_CANCEL));
257                 /* Cancel succeeded, we want to re-queue */
258                 mlog(0, "Lock %s, cancel succeeds, flags 0x%x\n",
259                      lockres->l_name, lockres->l_flags);
260                 lockres->l_requested = LKM_IVMODE; /* cancel an
261                                                     * upconvert
262                                                     * request. */
263                 lockres->l_flags &= ~USER_LOCK_IN_CANCEL;
264                 /* we want the unblock thread to look at it again
265                  * now. */
266                 if (lockres->l_flags & USER_LOCK_BLOCKED)
267                         __user_dlm_queue_lockres(lockres);
268         }
269
270         lockres->l_flags &= ~USER_LOCK_BUSY;
271 out_noclear:
272         spin_unlock(&lockres->l_lock);
273
274         wake_up(&lockres->l_event);
275 }
276
277 static inline void user_dlm_drop_inode_ref(struct user_lock_res *lockres)
278 {
279         struct inode *inode;
280         inode = user_dlm_inode_from_user_lockres(lockres);
281         iput(inode);
282 }
283
284 static void user_dlm_unblock_lock(void *opaque)
285 {
286         int new_level, status;
287         struct user_lock_res *lockres = (struct user_lock_res *) opaque;
288         struct dlm_ctxt *dlm = dlm_ctxt_from_user_lockres(lockres);
289
290         mlog(0, "processing lockres %s\n", lockres->l_name);
291
292         spin_lock(&lockres->l_lock);
293
294         mlog_bug_on_msg(!(lockres->l_flags & USER_LOCK_QUEUED),
295                         "Lockres %s, flags 0x%x\n",
296                         lockres->l_name, lockres->l_flags);
297
298         /* notice that we don't clear USER_LOCK_BLOCKED here. If it's
299          * set, we want user_ast clear it. */
300         lockres->l_flags &= ~USER_LOCK_QUEUED;
301
302         /* It's valid to get here and no longer be blocked - if we get
303          * several basts in a row, we might be queued by the first
304          * one, the unblock thread might run and clear the queued
305          * flag, and finally we might get another bast which re-queues
306          * us before our ast for the downconvert is called. */
307         if (!(lockres->l_flags & USER_LOCK_BLOCKED)) {
308                 mlog(0, "Lockres %s, flags 0x%x: queued but not blocking\n",
309                         lockres->l_name, lockres->l_flags);
310                 spin_unlock(&lockres->l_lock);
311                 goto drop_ref;
312         }
313
314         if (lockres->l_flags & USER_LOCK_IN_TEARDOWN) {
315                 mlog(0, "lock is in teardown so we do nothing\n");
316                 spin_unlock(&lockres->l_lock);
317                 goto drop_ref;
318         }
319
320         if (lockres->l_flags & USER_LOCK_BUSY) {
321                 mlog(0, "Cancel lock %s, flags 0x%x\n",
322                      lockres->l_name, lockres->l_flags);
323
324                 if (lockres->l_flags & USER_LOCK_IN_CANCEL) {
325                         spin_unlock(&lockres->l_lock);
326                         goto drop_ref;
327                 }
328
329                 lockres->l_flags |= USER_LOCK_IN_CANCEL;
330                 spin_unlock(&lockres->l_lock);
331
332                 status = dlmunlock(dlm,
333                                    &lockres->l_lksb,
334                                    LKM_CANCEL,
335                                    user_unlock_ast,
336                                    lockres);
337                 if (status != DLM_NORMAL)
338                         user_log_dlm_error("dlmunlock", status, lockres);
339                 goto drop_ref;
340         }
341
342         /* If there are still incompat holders, we can exit safely
343          * without worrying about re-queueing this lock as that will
344          * happen on the last call to user_cluster_unlock. */
345         if ((lockres->l_blocking == LKM_EXMODE)
346             && (lockres->l_ex_holders || lockres->l_ro_holders)) {
347                 spin_unlock(&lockres->l_lock);
348                 mlog(0, "can't downconvert for ex: ro = %u, ex = %u\n",
349                         lockres->l_ro_holders, lockres->l_ex_holders);
350                 goto drop_ref;
351         }
352
353         if ((lockres->l_blocking == LKM_PRMODE)
354             && lockres->l_ex_holders) {
355                 spin_unlock(&lockres->l_lock);
356                 mlog(0, "can't downconvert for pr: ex = %u\n",
357                         lockres->l_ex_holders);
358                 goto drop_ref;
359         }
360
361         /* yay, we can downconvert now. */
362         new_level = user_highest_compat_lock_level(lockres->l_blocking);
363         lockres->l_requested = new_level;
364         lockres->l_flags |= USER_LOCK_BUSY;
365         mlog(0, "Downconvert lock from %d to %d\n",
366                 lockres->l_level, new_level);
367         spin_unlock(&lockres->l_lock);
368
369         /* need lock downconvert request now... */
370         status = dlmlock(dlm,
371                          new_level,
372                          &lockres->l_lksb,
373                          LKM_CONVERT|LKM_VALBLK,
374                          lockres->l_name,
375                          user_ast,
376                          lockres,
377                          user_bast);
378         if (status != DLM_NORMAL) {
379                 user_log_dlm_error("dlmlock", status, lockres);
380                 user_recover_from_dlm_error(lockres);
381         }
382
383 drop_ref:
384         user_dlm_drop_inode_ref(lockres);
385 }
386
387 static inline void user_dlm_inc_holders(struct user_lock_res *lockres,
388                                         int level)
389 {
390         switch(level) {
391         case LKM_EXMODE:
392                 lockres->l_ex_holders++;
393                 break;
394         case LKM_PRMODE:
395                 lockres->l_ro_holders++;
396                 break;
397         default:
398                 BUG();
399         }
400 }
401
402 /* predict what lock level we'll be dropping down to on behalf
403  * of another node, and return true if the currently wanted
404  * level will be compatible with it. */
405 static inline int
406 user_may_continue_on_blocked_lock(struct user_lock_res *lockres,
407                                   int wanted)
408 {
409         BUG_ON(!(lockres->l_flags & USER_LOCK_BLOCKED));
410
411         return wanted <= user_highest_compat_lock_level(lockres->l_blocking);
412 }
413
414 int user_dlm_cluster_lock(struct user_lock_res *lockres,
415                           int level,
416                           int lkm_flags)
417 {
418         int status, local_flags;
419         struct dlm_ctxt *dlm = dlm_ctxt_from_user_lockres(lockres);
420
421         if (level != LKM_EXMODE &&
422             level != LKM_PRMODE) {
423                 mlog(ML_ERROR, "lockres %s: invalid request!\n",
424                      lockres->l_name);
425                 status = -EINVAL;
426                 goto bail;
427         }
428
429         mlog(0, "lockres %s: asking for %s lock, passed flags = 0x%x\n",
430                 lockres->l_name,
431                 (level == LKM_EXMODE) ? "LKM_EXMODE" : "LKM_PRMODE",
432                 lkm_flags);
433
434 again:
435         if (signal_pending(current)) {
436                 status = -ERESTARTSYS;
437                 goto bail;
438         }
439
440         spin_lock(&lockres->l_lock);
441
442         /* We only compare against the currently granted level
443          * here. If the lock is blocked waiting on a downconvert,
444          * we'll get caught below. */
445         if ((lockres->l_flags & USER_LOCK_BUSY) &&
446             (level > lockres->l_level)) {
447                 /* is someone sitting in dlm_lock? If so, wait on
448                  * them. */
449                 spin_unlock(&lockres->l_lock);
450
451                 user_wait_on_busy_lock(lockres);
452                 goto again;
453         }
454
455         if ((lockres->l_flags & USER_LOCK_BLOCKED) &&
456             (!user_may_continue_on_blocked_lock(lockres, level))) {
457                 /* is the lock is currently blocked on behalf of
458                  * another node */
459                 spin_unlock(&lockres->l_lock);
460
461                 user_wait_on_blocked_lock(lockres);
462                 goto again;
463         }
464
465         if (level > lockres->l_level) {
466                 local_flags = lkm_flags | LKM_VALBLK;
467                 if (lockres->l_level != LKM_IVMODE)
468                         local_flags |= LKM_CONVERT;
469
470                 lockres->l_requested = level;
471                 lockres->l_flags |= USER_LOCK_BUSY;
472                 spin_unlock(&lockres->l_lock);
473
474                 BUG_ON(level == LKM_IVMODE);
475                 BUG_ON(level == LKM_NLMODE);
476
477                 mlog(0, "lock %s, get lock from %d to level = %d\n",
478                         lockres->l_name, lockres->l_level, level);
479
480                 /* call dlm_lock to upgrade lock now */
481                 status = dlmlock(dlm,
482                                  level,
483                                  &lockres->l_lksb,
484                                  local_flags,
485                                  lockres->l_name,
486                                  user_ast,
487                                  lockres,
488                                  user_bast);
489                 if (status != DLM_NORMAL) {
490                         if ((lkm_flags & LKM_NOQUEUE) &&
491                             (status == DLM_NOTQUEUED))
492                                 status = -EAGAIN;
493                         else {
494                                 user_log_dlm_error("dlmlock", status, lockres);
495                                 status = -EINVAL;
496                         }
497                         user_recover_from_dlm_error(lockres);
498                         goto bail;
499                 }
500
501                 mlog(0, "lock %s, successfull return from dlmlock\n",
502                         lockres->l_name);
503
504                 user_wait_on_busy_lock(lockres);
505                 goto again;
506         }
507
508         user_dlm_inc_holders(lockres, level);
509         spin_unlock(&lockres->l_lock);
510
511         mlog(0, "lockres %s: Got %s lock!\n", lockres->l_name,
512                 (level == LKM_EXMODE) ? "LKM_EXMODE" : "LKM_PRMODE");
513
514         status = 0;
515 bail:
516         return status;
517 }
518
519 static inline void user_dlm_dec_holders(struct user_lock_res *lockres,
520                                         int level)
521 {
522         switch(level) {
523         case LKM_EXMODE:
524                 BUG_ON(!lockres->l_ex_holders);
525                 lockres->l_ex_holders--;
526                 break;
527         case LKM_PRMODE:
528                 BUG_ON(!lockres->l_ro_holders);
529                 lockres->l_ro_holders--;
530                 break;
531         default:
532                 BUG();
533         }
534 }
535
536 void user_dlm_cluster_unlock(struct user_lock_res *lockres,
537                              int level)
538 {
539         if (level != LKM_EXMODE &&
540             level != LKM_PRMODE) {
541                 mlog(ML_ERROR, "lockres %s: invalid request!\n", lockres->l_name);
542                 return;
543         }
544
545         mlog(0, "lockres %s: dropping %s lock\n", lockres->l_name,
546                 (level == LKM_EXMODE) ? "LKM_EXMODE" : "LKM_PRMODE");
547
548         spin_lock(&lockres->l_lock);
549         user_dlm_dec_holders(lockres, level);
550         __user_dlm_cond_queue_lockres(lockres);
551         spin_unlock(&lockres->l_lock);
552 }
553
554 void user_dlm_write_lvb(struct inode *inode,
555                         const char *val,
556                         unsigned int len)
557 {
558         struct user_lock_res *lockres = &DLMFS_I(inode)->ip_lockres;
559         char *lvb = lockres->l_lksb.lvb;
560
561         BUG_ON(len > DLM_LVB_LEN);
562
563         spin_lock(&lockres->l_lock);
564
565         BUG_ON(lockres->l_level < LKM_EXMODE);
566         memcpy(lvb, val, len);
567
568         spin_unlock(&lockres->l_lock);
569 }
570
571 void user_dlm_read_lvb(struct inode *inode,
572                        char *val,
573                        unsigned int len)
574 {
575         struct user_lock_res *lockres = &DLMFS_I(inode)->ip_lockres;
576         char *lvb = lockres->l_lksb.lvb;
577
578         BUG_ON(len > DLM_LVB_LEN);
579
580         spin_lock(&lockres->l_lock);
581
582         BUG_ON(lockres->l_level < LKM_PRMODE);
583         memcpy(val, lvb, len);
584
585         spin_unlock(&lockres->l_lock);
586 }
587
588 void user_dlm_lock_res_init(struct user_lock_res *lockres,
589                             struct dentry *dentry)
590 {
591         memset(lockres, 0, sizeof(*lockres));
592
593         spin_lock_init(&lockres->l_lock);
594         init_waitqueue_head(&lockres->l_event);
595         lockres->l_level = LKM_IVMODE;
596         lockres->l_requested = LKM_IVMODE;
597         lockres->l_blocking = LKM_IVMODE;
598
599         /* should have been checked before getting here. */
600         BUG_ON(dentry->d_name.len >= USER_DLM_LOCK_ID_MAX_LEN);
601
602         memcpy(lockres->l_name,
603                dentry->d_name.name,
604                dentry->d_name.len);
605 }
606
607 int user_dlm_destroy_lock(struct user_lock_res *lockres)
608 {
609         int status = -EBUSY;
610         struct dlm_ctxt *dlm = dlm_ctxt_from_user_lockres(lockres);
611
612         mlog(0, "asked to destroy %s\n", lockres->l_name);
613
614         spin_lock(&lockres->l_lock);
615         if (lockres->l_flags & USER_LOCK_IN_TEARDOWN) {
616                 mlog(0, "Lock is already torn down\n");
617                 spin_unlock(&lockres->l_lock);
618                 return 0;
619         }
620
621         lockres->l_flags |= USER_LOCK_IN_TEARDOWN;
622
623         while (lockres->l_flags & USER_LOCK_BUSY) {
624                 spin_unlock(&lockres->l_lock);
625
626                 mlog(0, "lock %s is busy\n", lockres->l_name);
627
628                 user_wait_on_busy_lock(lockres);
629
630                 spin_lock(&lockres->l_lock);
631         }
632
633         if (lockres->l_ro_holders || lockres->l_ex_holders) {
634                 spin_unlock(&lockres->l_lock);
635                 mlog(0, "lock %s has holders\n", lockres->l_name);
636                 goto bail;
637         }
638
639         status = 0;
640         if (!(lockres->l_flags & USER_LOCK_ATTACHED)) {
641                 spin_unlock(&lockres->l_lock);
642                 mlog(0, "lock %s is not attached\n", lockres->l_name);
643                 goto bail;
644         }
645
646         lockres->l_flags &= ~USER_LOCK_ATTACHED;
647         lockres->l_flags |= USER_LOCK_BUSY;
648         spin_unlock(&lockres->l_lock);
649
650         mlog(0, "unlocking lockres %s\n", lockres->l_name);
651         status = dlmunlock(dlm,
652                            &lockres->l_lksb,
653                            LKM_VALBLK,
654                            user_unlock_ast,
655                            lockres);
656         if (status != DLM_NORMAL) {
657                 user_log_dlm_error("dlmunlock", status, lockres);
658                 status = -EINVAL;
659                 goto bail;
660         }
661
662         user_wait_on_busy_lock(lockres);
663
664         status = 0;
665 bail:
666         return status;
667 }
668
669 struct dlm_ctxt *user_dlm_register_context(struct qstr *name)
670 {
671         struct dlm_ctxt *dlm;
672         u32 dlm_key;
673         char *domain;
674
675         domain = kmalloc(name->len + 1, GFP_NOFS);
676         if (!domain) {
677                 mlog_errno(-ENOMEM);
678                 return ERR_PTR(-ENOMEM);
679         }
680
681         dlm_key = crc32_le(0, name->name, name->len);
682
683         snprintf(domain, name->len + 1, "%.*s", name->len, name->name);
684
685         dlm = dlm_register_domain(domain, dlm_key);
686         if (IS_ERR(dlm))
687                 mlog_errno(PTR_ERR(dlm));
688
689         kfree(domain);
690         return dlm;
691 }
692
693 void user_dlm_unregister_context(struct dlm_ctxt *dlm)
694 {
695         dlm_unregister_domain(dlm);
696 }