mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-28 11:49:32 +00:00
![Junxiao Bi via Ocfs2-devel](/assets/img/avatar_default.png)
When user_dlm_destroy_lock failed, it didn't clean up the flags it set before exit. For USER_LOCK_IN_TEARDOWN, if this function fails because of lock is still in used, next time when unlink invokes this function, it will return succeed, and then unlink will remove inode and dentry if lock is not in used(file closed), but the dlm lock is still linked in dlm lock resource, then when bast come in, it will trigger a panic due to user-after-free. See the following panic call trace. To fix this, USER_LOCK_IN_TEARDOWN should be reverted if fail. And also error should be returned if USER_LOCK_IN_TEARDOWN is set to let user know that unlink fail. For the case of ocfs2_dlm_unlock failure, besides USER_LOCK_IN_TEARDOWN, USER_LOCK_BUSY is also required to be cleared. Even though spin lock is released in between, but USER_LOCK_IN_TEARDOWN is still set, for USER_LOCK_BUSY, if before every place that waits on this flag, USER_LOCK_IN_TEARDOWN is checked to bail out, that will make sure no flow waits on the busy flag set by user_dlm_destroy_lock(), then we can simplely revert USER_LOCK_BUSY when ocfs2_dlm_unlock fails. Fix user_dlm_cluster_lock() which is the only function not following this. [ 941.336392] (python,26174,16):dlmfs_unlink:562 ERROR: unlink 004fb0000060000b5a90b8c847b72e1, error -16 from destroy [ 989.757536] ------------[ cut here ]------------ [ 989.757709] kernel BUG at fs/ocfs2/dlmfs/userdlm.c:173! [ 989.757876] invalid opcode: 0000 [#1] SMP [ 989.758027] Modules linked in: ksplice_2zhuk2jr_ib_ipoib_new(O) ksplice_2zhuk2jr(O) mptctl mptbase xen_netback xen_blkback xen_gntalloc xen_gntdev xen_evtchn cdc_ether usbnet mii ocfs2 jbd2 rpcsec_gss_krb5 auth_rpcgss nfsv4 nfsv3 nfs_acl nfs fscache lockd grace ocfs2_dlmfs ocfs2_stack_o2cb ocfs2_dlm ocfs2_nodemanager ocfs2_stackglue configfs bnx2fc fcoe libfcoe libfc scsi_transport_fc sunrpc ipmi_devintf bridge stp llc rds_rdma rds bonding ib_sdp ib_ipoib rdma_ucm ib_ucm ib_uverbs ib_umad rdma_cm ib_cm iw_cm falcon_lsm_serviceable(PE) falcon_nf_netcontain(PE) mlx4_vnic falcon_kal(E) falcon_lsm_pinned_13402(E) mlx4_ib ib_sa ib_mad ib_core ib_addr xenfs xen_privcmd dm_multipath iTCO_wdt iTCO_vendor_support pcspkr sb_edac edac_core i2c_i801 lpc_ich mfd_core ipmi_ssif i2c_core ipmi_si ipmi_msghandler [ 989.760686] ioatdma sg ext3 jbd mbcache sd_mod ahci libahci ixgbe dca ptp pps_core vxlan udp_tunnel ip6_udp_tunnel megaraid_sas mlx4_core crc32c_intel be2iscsi bnx2i cnic uio cxgb4i cxgb4 cxgb3i libcxgbi ipv6 cxgb3 mdio libiscsi_tcp qla4xxx iscsi_boot_sysfs libiscsi scsi_transport_iscsi wmi dm_mirror dm_region_hash dm_log dm_mod [last unloaded: ksplice_2zhuk2jr_ib_ipoib_old] [ 989.761987] CPU: 10 PID: 19102 Comm: dlm_thread Tainted: P OE 4.1.12-124.57.1.el6uek.x86_64 #2 [ 989.762290] Hardware name: Oracle Corporation ORACLE SERVER X5-2/ASM,MOTHERBOARD,1U, BIOS 30350100 06/17/2021 [ 989.762599] task: ffff880178af6200 ti: ffff88017f7c8000 task.ti: ffff88017f7c8000 [ 989.762848] RIP: e030:[<ffffffffc07d4316>] [<ffffffffc07d4316>] __user_dlm_queue_lockres.part.4+0x76/0x80 [ocfs2_dlmfs] [ 989.763185] RSP: e02b:ffff88017f7cbcb8 EFLAGS: 00010246 [ 989.763353] RAX: 0000000000000000 RBX: ffff880174d48008 RCX: 0000000000000003 [ 989.763565] RDX: 0000000000120012 RSI: 0000000000000003 RDI: ffff880174d48170 [ 989.763778] RBP: ffff88017f7cbcc8 R08: ffff88021f4293b0 R09: 0000000000000000 [ 989.763991] R10: ffff880179c8c000 R11: 0000000000000003 R12: ffff880174d48008 [ 989.764204] R13: 0000000000000003 R14: ffff880179c8c000 R15: ffff88021db7a000 [ 989.764422] FS: 0000000000000000(0000) GS:ffff880247480000(0000) knlGS:ffff880247480000 [ 989.764685] CS: e033 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 989.764865] CR2: ffff8000007f6800 CR3: 0000000001ae0000 CR4: 0000000000042660 [ 989.765081] Stack: [ 989.765167] 0000000000000003 ffff880174d48040 ffff88017f7cbd18 ffffffffc07d455f [ 989.765442] ffff88017f7cbd88 ffffffff816fb639 ffff88017f7cbd38 ffff8800361b5600 [ 989.765717] ffff88021db7a000 ffff88021f429380 0000000000000003 ffffffffc0453020 [ 989.765991] Call Trace: [ 989.766093] [<ffffffffc07d455f>] user_bast+0x5f/0xf0 [ocfs2_dlmfs] [ 989.766287] [<ffffffff816fb639>] ? schedule_timeout+0x169/0x2d0 [ 989.766475] [<ffffffffc0453020>] ? o2dlm_lock_ast_wrapper+0x20/0x20 [ocfs2_stack_o2cb] [ 989.766738] [<ffffffffc045303a>] o2dlm_blocking_ast_wrapper+0x1a/0x20 [ocfs2_stack_o2cb] [ 989.767010] [<ffffffffc0864ec6>] dlm_do_local_bast+0x46/0xe0 [ocfs2_dlm] [ 989.767217] [<ffffffffc084f5cc>] ? dlm_lockres_calc_usage+0x4c/0x60 [ocfs2_dlm] [ 989.767466] [<ffffffffc08501f1>] dlm_thread+0xa31/0x1140 [ocfs2_dlm] [ 989.767662] [<ffffffff816f78da>] ? __schedule+0x24a/0x810 [ 989.767834] [<ffffffff816f78ce>] ? __schedule+0x23e/0x810 [ 989.768006] [<ffffffff816f78da>] ? __schedule+0x24a/0x810 [ 989.768178] [<ffffffff816f78ce>] ? __schedule+0x23e/0x810 [ 989.768349] [<ffffffff816f78da>] ? __schedule+0x24a/0x810 [ 989.768521] [<ffffffff816f78ce>] ? __schedule+0x23e/0x810 [ 989.768693] [<ffffffff816f78da>] ? __schedule+0x24a/0x810 [ 989.768893] [<ffffffff816f78ce>] ? __schedule+0x23e/0x810 [ 989.769067] [<ffffffff816f78da>] ? __schedule+0x24a/0x810 [ 989.769241] [<ffffffff810ce4d0>] ? wait_woken+0x90/0x90 [ 989.769411] [<ffffffffc084f7c0>] ? dlm_kick_thread+0x80/0x80 [ocfs2_dlm] [ 989.769617] [<ffffffff810a8bbb>] kthread+0xcb/0xf0 [ 989.769774] [<ffffffff816f78da>] ? __schedule+0x24a/0x810 [ 989.769945] [<ffffffff816f78da>] ? __schedule+0x24a/0x810 [ 989.770117] [<ffffffff810a8af0>] ? kthread_create_on_node+0x180/0x180 [ 989.770321] [<ffffffff816fdaa1>] ret_from_fork+0x61/0x90 [ 989.770492] [<ffffffff810a8af0>] ? kthread_create_on_node+0x180/0x180 [ 989.770689] Code: d0 00 00 00 f0 45 7d c0 bf 00 20 00 00 48 89 83 c0 00 00 00 48 89 83 c8 00 00 00 e8 55 c1 8c c0 83 4b 04 10 48 83 c4 08 5b 5d c3 <0f> 0b 0f 1f 84 00 00 00 00 00 55 48 89 e5 41 55 41 54 53 48 83 [ 989.771892] RIP [<ffffffffc07d4316>] __user_dlm_queue_lockres.part.4+0x76/0x80 [ocfs2_dlmfs] [ 989.772174] RSP <ffff88017f7cbcb8> [ 989.772704] ---[ end trace ebd1e38cebcc93a8 ]--- [ 989.772907] Kernel panic - not syncing: Fatal exception [ 989.773173] Kernel Offset: disabled Link: https://lkml.kernel.org/r/20220518235224.87100-2-junxiao.bi@oracle.com Signed-off-by: Junxiao Bi <junxiao.bi@oracle.com> Reviewed-by: Joseph Qi <joseph.qi@linux.alibaba.com> Cc: Mark Fasheh <mark@fasheh.com> Cc: Joel Becker <jlbec@evilplan.org> Cc: Joseph Qi <jiangqi903@gmail.com> Cc: Changwei Ge <gechangwei@live.cn> Cc: Gang He <ghe@suse.com> Cc: Jun Piao <piaojun@huawei.com> Cc: <stable@vger.kernel.org> Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
682 lines
17 KiB
C
682 lines
17 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* userdlm.c
|
|
*
|
|
* Code which implements the kernel side of a minimal userspace
|
|
* interface to our DLM.
|
|
*
|
|
* Many of the functions here are pared down versions of dlmglue.c
|
|
* functions.
|
|
*
|
|
* Copyright (C) 2003, 2004 Oracle. All rights reserved.
|
|
*/
|
|
|
|
#include <linux/signal.h>
|
|
#include <linux/sched/signal.h>
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/types.h>
|
|
#include <linux/crc32.h>
|
|
|
|
#include "../ocfs2_lockingver.h"
|
|
#include "../stackglue.h"
|
|
#include "userdlm.h"
|
|
|
|
#define MLOG_MASK_PREFIX ML_DLMFS
|
|
#include "../cluster/masklog.h"
|
|
|
|
|
|
static inline struct user_lock_res *user_lksb_to_lock_res(struct ocfs2_dlm_lksb *lksb)
|
|
{
|
|
return container_of(lksb, struct user_lock_res, l_lksb);
|
|
}
|
|
|
|
static inline int user_check_wait_flag(struct user_lock_res *lockres,
|
|
int flag)
|
|
{
|
|
int ret;
|
|
|
|
spin_lock(&lockres->l_lock);
|
|
ret = lockres->l_flags & flag;
|
|
spin_unlock(&lockres->l_lock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static inline void user_wait_on_busy_lock(struct user_lock_res *lockres)
|
|
|
|
{
|
|
wait_event(lockres->l_event,
|
|
!user_check_wait_flag(lockres, USER_LOCK_BUSY));
|
|
}
|
|
|
|
static inline void user_wait_on_blocked_lock(struct user_lock_res *lockres)
|
|
|
|
{
|
|
wait_event(lockres->l_event,
|
|
!user_check_wait_flag(lockres, USER_LOCK_BLOCKED));
|
|
}
|
|
|
|
/* I heart container_of... */
|
|
static inline struct ocfs2_cluster_connection *
|
|
cluster_connection_from_user_lockres(struct user_lock_res *lockres)
|
|
{
|
|
struct dlmfs_inode_private *ip;
|
|
|
|
ip = container_of(lockres,
|
|
struct dlmfs_inode_private,
|
|
ip_lockres);
|
|
return ip->ip_conn;
|
|
}
|
|
|
|
static struct inode *
|
|
user_dlm_inode_from_user_lockres(struct user_lock_res *lockres)
|
|
{
|
|
struct dlmfs_inode_private *ip;
|
|
|
|
ip = container_of(lockres,
|
|
struct dlmfs_inode_private,
|
|
ip_lockres);
|
|
return &ip->ip_vfs_inode;
|
|
}
|
|
|
|
static inline void user_recover_from_dlm_error(struct user_lock_res *lockres)
|
|
{
|
|
spin_lock(&lockres->l_lock);
|
|
lockres->l_flags &= ~USER_LOCK_BUSY;
|
|
spin_unlock(&lockres->l_lock);
|
|
}
|
|
|
|
#define user_log_dlm_error(_func, _stat, _lockres) do { \
|
|
mlog(ML_ERROR, "Dlm error %d while calling %s on " \
|
|
"resource %.*s\n", _stat, _func, \
|
|
_lockres->l_namelen, _lockres->l_name); \
|
|
} while (0)
|
|
|
|
/* WARNING: This function lives in a world where the only three lock
|
|
* levels are EX, PR, and NL. It *will* have to be adjusted when more
|
|
* lock types are added. */
|
|
static inline int user_highest_compat_lock_level(int level)
|
|
{
|
|
int new_level = DLM_LOCK_EX;
|
|
|
|
if (level == DLM_LOCK_EX)
|
|
new_level = DLM_LOCK_NL;
|
|
else if (level == DLM_LOCK_PR)
|
|
new_level = DLM_LOCK_PR;
|
|
return new_level;
|
|
}
|
|
|
|
static void user_ast(struct ocfs2_dlm_lksb *lksb)
|
|
{
|
|
struct user_lock_res *lockres = user_lksb_to_lock_res(lksb);
|
|
int status;
|
|
|
|
mlog(ML_BASTS, "AST fired for lockres %.*s, level %d => %d\n",
|
|
lockres->l_namelen, lockres->l_name, lockres->l_level,
|
|
lockres->l_requested);
|
|
|
|
spin_lock(&lockres->l_lock);
|
|
|
|
status = ocfs2_dlm_lock_status(&lockres->l_lksb);
|
|
if (status) {
|
|
mlog(ML_ERROR, "lksb status value of %u on lockres %.*s\n",
|
|
status, lockres->l_namelen, lockres->l_name);
|
|
spin_unlock(&lockres->l_lock);
|
|
return;
|
|
}
|
|
|
|
mlog_bug_on_msg(lockres->l_requested == DLM_LOCK_IV,
|
|
"Lockres %.*s, requested ivmode. flags 0x%x\n",
|
|
lockres->l_namelen, lockres->l_name, lockres->l_flags);
|
|
|
|
/* we're downconverting. */
|
|
if (lockres->l_requested < lockres->l_level) {
|
|
if (lockres->l_requested <=
|
|
user_highest_compat_lock_level(lockres->l_blocking)) {
|
|
lockres->l_blocking = DLM_LOCK_NL;
|
|
lockres->l_flags &= ~USER_LOCK_BLOCKED;
|
|
}
|
|
}
|
|
|
|
lockres->l_level = lockres->l_requested;
|
|
lockres->l_requested = DLM_LOCK_IV;
|
|
lockres->l_flags |= USER_LOCK_ATTACHED;
|
|
lockres->l_flags &= ~USER_LOCK_BUSY;
|
|
|
|
spin_unlock(&lockres->l_lock);
|
|
|
|
wake_up(&lockres->l_event);
|
|
}
|
|
|
|
static inline void user_dlm_grab_inode_ref(struct user_lock_res *lockres)
|
|
{
|
|
struct inode *inode;
|
|
inode = user_dlm_inode_from_user_lockres(lockres);
|
|
if (!igrab(inode))
|
|
BUG();
|
|
}
|
|
|
|
static void user_dlm_unblock_lock(struct work_struct *work);
|
|
|
|
static void __user_dlm_queue_lockres(struct user_lock_res *lockres)
|
|
{
|
|
if (!(lockres->l_flags & USER_LOCK_QUEUED)) {
|
|
user_dlm_grab_inode_ref(lockres);
|
|
|
|
INIT_WORK(&lockres->l_work, user_dlm_unblock_lock);
|
|
|
|
queue_work(user_dlm_worker, &lockres->l_work);
|
|
lockres->l_flags |= USER_LOCK_QUEUED;
|
|
}
|
|
}
|
|
|
|
static void __user_dlm_cond_queue_lockres(struct user_lock_res *lockres)
|
|
{
|
|
int queue = 0;
|
|
|
|
if (!(lockres->l_flags & USER_LOCK_BLOCKED))
|
|
return;
|
|
|
|
switch (lockres->l_blocking) {
|
|
case DLM_LOCK_EX:
|
|
if (!lockres->l_ex_holders && !lockres->l_ro_holders)
|
|
queue = 1;
|
|
break;
|
|
case DLM_LOCK_PR:
|
|
if (!lockres->l_ex_holders)
|
|
queue = 1;
|
|
break;
|
|
default:
|
|
BUG();
|
|
}
|
|
|
|
if (queue)
|
|
__user_dlm_queue_lockres(lockres);
|
|
}
|
|
|
|
static void user_bast(struct ocfs2_dlm_lksb *lksb, int level)
|
|
{
|
|
struct user_lock_res *lockres = user_lksb_to_lock_res(lksb);
|
|
|
|
mlog(ML_BASTS, "BAST fired for lockres %.*s, blocking %d, level %d\n",
|
|
lockres->l_namelen, lockres->l_name, level, lockres->l_level);
|
|
|
|
spin_lock(&lockres->l_lock);
|
|
lockres->l_flags |= USER_LOCK_BLOCKED;
|
|
if (level > lockres->l_blocking)
|
|
lockres->l_blocking = level;
|
|
|
|
__user_dlm_queue_lockres(lockres);
|
|
spin_unlock(&lockres->l_lock);
|
|
|
|
wake_up(&lockres->l_event);
|
|
}
|
|
|
|
static void user_unlock_ast(struct ocfs2_dlm_lksb *lksb, int status)
|
|
{
|
|
struct user_lock_res *lockres = user_lksb_to_lock_res(lksb);
|
|
|
|
mlog(ML_BASTS, "UNLOCK AST fired for lockres %.*s, flags 0x%x\n",
|
|
lockres->l_namelen, lockres->l_name, lockres->l_flags);
|
|
|
|
if (status)
|
|
mlog(ML_ERROR, "dlm returns status %d\n", status);
|
|
|
|
spin_lock(&lockres->l_lock);
|
|
/* The teardown flag gets set early during the unlock process,
|
|
* so test the cancel flag to make sure that this ast isn't
|
|
* for a concurrent cancel. */
|
|
if (lockres->l_flags & USER_LOCK_IN_TEARDOWN
|
|
&& !(lockres->l_flags & USER_LOCK_IN_CANCEL)) {
|
|
lockres->l_level = DLM_LOCK_IV;
|
|
} else if (status == DLM_CANCELGRANT) {
|
|
/* We tried to cancel a convert request, but it was
|
|
* already granted. Don't clear the busy flag - the
|
|
* ast should've done this already. */
|
|
BUG_ON(!(lockres->l_flags & USER_LOCK_IN_CANCEL));
|
|
lockres->l_flags &= ~USER_LOCK_IN_CANCEL;
|
|
goto out_noclear;
|
|
} else {
|
|
BUG_ON(!(lockres->l_flags & USER_LOCK_IN_CANCEL));
|
|
/* Cancel succeeded, we want to re-queue */
|
|
lockres->l_requested = DLM_LOCK_IV; /* cancel an
|
|
* upconvert
|
|
* request. */
|
|
lockres->l_flags &= ~USER_LOCK_IN_CANCEL;
|
|
/* we want the unblock thread to look at it again
|
|
* now. */
|
|
if (lockres->l_flags & USER_LOCK_BLOCKED)
|
|
__user_dlm_queue_lockres(lockres);
|
|
}
|
|
|
|
lockres->l_flags &= ~USER_LOCK_BUSY;
|
|
out_noclear:
|
|
spin_unlock(&lockres->l_lock);
|
|
|
|
wake_up(&lockres->l_event);
|
|
}
|
|
|
|
/*
|
|
* This is the userdlmfs locking protocol version.
|
|
*
|
|
* See fs/ocfs2/dlmglue.c for more details on locking versions.
|
|
*/
|
|
static struct ocfs2_locking_protocol user_dlm_lproto = {
|
|
.lp_max_version = {
|
|
.pv_major = OCFS2_LOCKING_PROTOCOL_MAJOR,
|
|
.pv_minor = OCFS2_LOCKING_PROTOCOL_MINOR,
|
|
},
|
|
.lp_lock_ast = user_ast,
|
|
.lp_blocking_ast = user_bast,
|
|
.lp_unlock_ast = user_unlock_ast,
|
|
};
|
|
|
|
static inline void user_dlm_drop_inode_ref(struct user_lock_res *lockres)
|
|
{
|
|
struct inode *inode;
|
|
inode = user_dlm_inode_from_user_lockres(lockres);
|
|
iput(inode);
|
|
}
|
|
|
|
static void user_dlm_unblock_lock(struct work_struct *work)
|
|
{
|
|
int new_level, status;
|
|
struct user_lock_res *lockres =
|
|
container_of(work, struct user_lock_res, l_work);
|
|
struct ocfs2_cluster_connection *conn =
|
|
cluster_connection_from_user_lockres(lockres);
|
|
|
|
mlog(0, "lockres %.*s\n", lockres->l_namelen, lockres->l_name);
|
|
|
|
spin_lock(&lockres->l_lock);
|
|
|
|
mlog_bug_on_msg(!(lockres->l_flags & USER_LOCK_QUEUED),
|
|
"Lockres %.*s, flags 0x%x\n",
|
|
lockres->l_namelen, lockres->l_name, lockres->l_flags);
|
|
|
|
/* notice that we don't clear USER_LOCK_BLOCKED here. If it's
|
|
* set, we want user_ast clear it. */
|
|
lockres->l_flags &= ~USER_LOCK_QUEUED;
|
|
|
|
/* It's valid to get here and no longer be blocked - if we get
|
|
* several basts in a row, we might be queued by the first
|
|
* one, the unblock thread might run and clear the queued
|
|
* flag, and finally we might get another bast which re-queues
|
|
* us before our ast for the downconvert is called. */
|
|
if (!(lockres->l_flags & USER_LOCK_BLOCKED)) {
|
|
mlog(ML_BASTS, "lockres %.*s USER_LOCK_BLOCKED\n",
|
|
lockres->l_namelen, lockres->l_name);
|
|
spin_unlock(&lockres->l_lock);
|
|
goto drop_ref;
|
|
}
|
|
|
|
if (lockres->l_flags & USER_LOCK_IN_TEARDOWN) {
|
|
mlog(ML_BASTS, "lockres %.*s USER_LOCK_IN_TEARDOWN\n",
|
|
lockres->l_namelen, lockres->l_name);
|
|
spin_unlock(&lockres->l_lock);
|
|
goto drop_ref;
|
|
}
|
|
|
|
if (lockres->l_flags & USER_LOCK_BUSY) {
|
|
if (lockres->l_flags & USER_LOCK_IN_CANCEL) {
|
|
mlog(ML_BASTS, "lockres %.*s USER_LOCK_IN_CANCEL\n",
|
|
lockres->l_namelen, lockres->l_name);
|
|
spin_unlock(&lockres->l_lock);
|
|
goto drop_ref;
|
|
}
|
|
|
|
lockres->l_flags |= USER_LOCK_IN_CANCEL;
|
|
spin_unlock(&lockres->l_lock);
|
|
|
|
status = ocfs2_dlm_unlock(conn, &lockres->l_lksb,
|
|
DLM_LKF_CANCEL);
|
|
if (status)
|
|
user_log_dlm_error("ocfs2_dlm_unlock", status, lockres);
|
|
goto drop_ref;
|
|
}
|
|
|
|
/* If there are still incompat holders, we can exit safely
|
|
* without worrying about re-queueing this lock as that will
|
|
* happen on the last call to user_cluster_unlock. */
|
|
if ((lockres->l_blocking == DLM_LOCK_EX)
|
|
&& (lockres->l_ex_holders || lockres->l_ro_holders)) {
|
|
spin_unlock(&lockres->l_lock);
|
|
mlog(ML_BASTS, "lockres %.*s, EX/PR Holders %u,%u\n",
|
|
lockres->l_namelen, lockres->l_name,
|
|
lockres->l_ex_holders, lockres->l_ro_holders);
|
|
goto drop_ref;
|
|
}
|
|
|
|
if ((lockres->l_blocking == DLM_LOCK_PR)
|
|
&& lockres->l_ex_holders) {
|
|
spin_unlock(&lockres->l_lock);
|
|
mlog(ML_BASTS, "lockres %.*s, EX Holders %u\n",
|
|
lockres->l_namelen, lockres->l_name,
|
|
lockres->l_ex_holders);
|
|
goto drop_ref;
|
|
}
|
|
|
|
/* yay, we can downconvert now. */
|
|
new_level = user_highest_compat_lock_level(lockres->l_blocking);
|
|
lockres->l_requested = new_level;
|
|
lockres->l_flags |= USER_LOCK_BUSY;
|
|
mlog(ML_BASTS, "lockres %.*s, downconvert %d => %d\n",
|
|
lockres->l_namelen, lockres->l_name, lockres->l_level, new_level);
|
|
spin_unlock(&lockres->l_lock);
|
|
|
|
/* need lock downconvert request now... */
|
|
status = ocfs2_dlm_lock(conn, new_level, &lockres->l_lksb,
|
|
DLM_LKF_CONVERT|DLM_LKF_VALBLK,
|
|
lockres->l_name,
|
|
lockres->l_namelen);
|
|
if (status) {
|
|
user_log_dlm_error("ocfs2_dlm_lock", status, lockres);
|
|
user_recover_from_dlm_error(lockres);
|
|
}
|
|
|
|
drop_ref:
|
|
user_dlm_drop_inode_ref(lockres);
|
|
}
|
|
|
|
static inline void user_dlm_inc_holders(struct user_lock_res *lockres,
|
|
int level)
|
|
{
|
|
switch(level) {
|
|
case DLM_LOCK_EX:
|
|
lockres->l_ex_holders++;
|
|
break;
|
|
case DLM_LOCK_PR:
|
|
lockres->l_ro_holders++;
|
|
break;
|
|
default:
|
|
BUG();
|
|
}
|
|
}
|
|
|
|
/* predict what lock level we'll be dropping down to on behalf
|
|
* of another node, and return true if the currently wanted
|
|
* level will be compatible with it. */
|
|
static inline int
|
|
user_may_continue_on_blocked_lock(struct user_lock_res *lockres,
|
|
int wanted)
|
|
{
|
|
BUG_ON(!(lockres->l_flags & USER_LOCK_BLOCKED));
|
|
|
|
return wanted <= user_highest_compat_lock_level(lockres->l_blocking);
|
|
}
|
|
|
|
int user_dlm_cluster_lock(struct user_lock_res *lockres,
|
|
int level,
|
|
int lkm_flags)
|
|
{
|
|
int status, local_flags;
|
|
struct ocfs2_cluster_connection *conn =
|
|
cluster_connection_from_user_lockres(lockres);
|
|
|
|
if (level != DLM_LOCK_EX &&
|
|
level != DLM_LOCK_PR) {
|
|
mlog(ML_ERROR, "lockres %.*s: invalid request!\n",
|
|
lockres->l_namelen, lockres->l_name);
|
|
status = -EINVAL;
|
|
goto bail;
|
|
}
|
|
|
|
mlog(ML_BASTS, "lockres %.*s, level %d, flags = 0x%x\n",
|
|
lockres->l_namelen, lockres->l_name, level, lkm_flags);
|
|
|
|
again:
|
|
if (signal_pending(current)) {
|
|
status = -ERESTARTSYS;
|
|
goto bail;
|
|
}
|
|
|
|
spin_lock(&lockres->l_lock);
|
|
if (lockres->l_flags & USER_LOCK_IN_TEARDOWN) {
|
|
spin_unlock(&lockres->l_lock);
|
|
status = -EAGAIN;
|
|
goto bail;
|
|
}
|
|
|
|
/* We only compare against the currently granted level
|
|
* here. If the lock is blocked waiting on a downconvert,
|
|
* we'll get caught below. */
|
|
if ((lockres->l_flags & USER_LOCK_BUSY) &&
|
|
(level > lockres->l_level)) {
|
|
/* is someone sitting in dlm_lock? If so, wait on
|
|
* them. */
|
|
spin_unlock(&lockres->l_lock);
|
|
|
|
user_wait_on_busy_lock(lockres);
|
|
goto again;
|
|
}
|
|
|
|
if ((lockres->l_flags & USER_LOCK_BLOCKED) &&
|
|
(!user_may_continue_on_blocked_lock(lockres, level))) {
|
|
/* is the lock is currently blocked on behalf of
|
|
* another node */
|
|
spin_unlock(&lockres->l_lock);
|
|
|
|
user_wait_on_blocked_lock(lockres);
|
|
goto again;
|
|
}
|
|
|
|
if (level > lockres->l_level) {
|
|
local_flags = lkm_flags | DLM_LKF_VALBLK;
|
|
if (lockres->l_level != DLM_LOCK_IV)
|
|
local_flags |= DLM_LKF_CONVERT;
|
|
|
|
lockres->l_requested = level;
|
|
lockres->l_flags |= USER_LOCK_BUSY;
|
|
spin_unlock(&lockres->l_lock);
|
|
|
|
BUG_ON(level == DLM_LOCK_IV);
|
|
BUG_ON(level == DLM_LOCK_NL);
|
|
|
|
/* call dlm_lock to upgrade lock now */
|
|
status = ocfs2_dlm_lock(conn, level, &lockres->l_lksb,
|
|
local_flags, lockres->l_name,
|
|
lockres->l_namelen);
|
|
if (status) {
|
|
if ((lkm_flags & DLM_LKF_NOQUEUE) &&
|
|
(status != -EAGAIN))
|
|
user_log_dlm_error("ocfs2_dlm_lock",
|
|
status, lockres);
|
|
user_recover_from_dlm_error(lockres);
|
|
goto bail;
|
|
}
|
|
|
|
user_wait_on_busy_lock(lockres);
|
|
goto again;
|
|
}
|
|
|
|
user_dlm_inc_holders(lockres, level);
|
|
spin_unlock(&lockres->l_lock);
|
|
|
|
status = 0;
|
|
bail:
|
|
return status;
|
|
}
|
|
|
|
static inline void user_dlm_dec_holders(struct user_lock_res *lockres,
|
|
int level)
|
|
{
|
|
switch(level) {
|
|
case DLM_LOCK_EX:
|
|
BUG_ON(!lockres->l_ex_holders);
|
|
lockres->l_ex_holders--;
|
|
break;
|
|
case DLM_LOCK_PR:
|
|
BUG_ON(!lockres->l_ro_holders);
|
|
lockres->l_ro_holders--;
|
|
break;
|
|
default:
|
|
BUG();
|
|
}
|
|
}
|
|
|
|
void user_dlm_cluster_unlock(struct user_lock_res *lockres,
|
|
int level)
|
|
{
|
|
if (level != DLM_LOCK_EX &&
|
|
level != DLM_LOCK_PR) {
|
|
mlog(ML_ERROR, "lockres %.*s: invalid request!\n",
|
|
lockres->l_namelen, lockres->l_name);
|
|
return;
|
|
}
|
|
|
|
spin_lock(&lockres->l_lock);
|
|
user_dlm_dec_holders(lockres, level);
|
|
__user_dlm_cond_queue_lockres(lockres);
|
|
spin_unlock(&lockres->l_lock);
|
|
}
|
|
|
|
void user_dlm_write_lvb(struct inode *inode,
|
|
const char *val,
|
|
unsigned int len)
|
|
{
|
|
struct user_lock_res *lockres = &DLMFS_I(inode)->ip_lockres;
|
|
char *lvb;
|
|
|
|
BUG_ON(len > DLM_LVB_LEN);
|
|
|
|
spin_lock(&lockres->l_lock);
|
|
|
|
BUG_ON(lockres->l_level < DLM_LOCK_EX);
|
|
lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
|
|
memcpy(lvb, val, len);
|
|
|
|
spin_unlock(&lockres->l_lock);
|
|
}
|
|
|
|
bool user_dlm_read_lvb(struct inode *inode, char *val)
|
|
{
|
|
struct user_lock_res *lockres = &DLMFS_I(inode)->ip_lockres;
|
|
char *lvb;
|
|
bool ret = true;
|
|
|
|
spin_lock(&lockres->l_lock);
|
|
|
|
BUG_ON(lockres->l_level < DLM_LOCK_PR);
|
|
if (ocfs2_dlm_lvb_valid(&lockres->l_lksb)) {
|
|
lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
|
|
memcpy(val, lvb, DLM_LVB_LEN);
|
|
} else
|
|
ret = false;
|
|
|
|
spin_unlock(&lockres->l_lock);
|
|
return ret;
|
|
}
|
|
|
|
void user_dlm_lock_res_init(struct user_lock_res *lockres,
|
|
struct dentry *dentry)
|
|
{
|
|
memset(lockres, 0, sizeof(*lockres));
|
|
|
|
spin_lock_init(&lockres->l_lock);
|
|
init_waitqueue_head(&lockres->l_event);
|
|
lockres->l_level = DLM_LOCK_IV;
|
|
lockres->l_requested = DLM_LOCK_IV;
|
|
lockres->l_blocking = DLM_LOCK_IV;
|
|
|
|
/* should have been checked before getting here. */
|
|
BUG_ON(dentry->d_name.len >= USER_DLM_LOCK_ID_MAX_LEN);
|
|
|
|
memcpy(lockres->l_name,
|
|
dentry->d_name.name,
|
|
dentry->d_name.len);
|
|
lockres->l_namelen = dentry->d_name.len;
|
|
}
|
|
|
|
int user_dlm_destroy_lock(struct user_lock_res *lockres)
|
|
{
|
|
int status = -EBUSY;
|
|
struct ocfs2_cluster_connection *conn =
|
|
cluster_connection_from_user_lockres(lockres);
|
|
|
|
mlog(ML_BASTS, "lockres %.*s\n", lockres->l_namelen, lockres->l_name);
|
|
|
|
spin_lock(&lockres->l_lock);
|
|
if (lockres->l_flags & USER_LOCK_IN_TEARDOWN) {
|
|
spin_unlock(&lockres->l_lock);
|
|
goto bail;
|
|
}
|
|
|
|
lockres->l_flags |= USER_LOCK_IN_TEARDOWN;
|
|
|
|
while (lockres->l_flags & USER_LOCK_BUSY) {
|
|
spin_unlock(&lockres->l_lock);
|
|
|
|
user_wait_on_busy_lock(lockres);
|
|
|
|
spin_lock(&lockres->l_lock);
|
|
}
|
|
|
|
if (lockres->l_ro_holders || lockres->l_ex_holders) {
|
|
lockres->l_flags &= ~USER_LOCK_IN_TEARDOWN;
|
|
spin_unlock(&lockres->l_lock);
|
|
goto bail;
|
|
}
|
|
|
|
status = 0;
|
|
if (!(lockres->l_flags & USER_LOCK_ATTACHED)) {
|
|
/*
|
|
* lock is never requested, leave USER_LOCK_IN_TEARDOWN set
|
|
* to avoid new lock request coming in.
|
|
*/
|
|
spin_unlock(&lockres->l_lock);
|
|
goto bail;
|
|
}
|
|
|
|
lockres->l_flags |= USER_LOCK_BUSY;
|
|
spin_unlock(&lockres->l_lock);
|
|
|
|
status = ocfs2_dlm_unlock(conn, &lockres->l_lksb, DLM_LKF_VALBLK);
|
|
if (status) {
|
|
spin_lock(&lockres->l_lock);
|
|
lockres->l_flags &= ~USER_LOCK_IN_TEARDOWN;
|
|
lockres->l_flags &= ~USER_LOCK_BUSY;
|
|
spin_unlock(&lockres->l_lock);
|
|
user_log_dlm_error("ocfs2_dlm_unlock", status, lockres);
|
|
goto bail;
|
|
}
|
|
|
|
user_wait_on_busy_lock(lockres);
|
|
|
|
status = 0;
|
|
bail:
|
|
return status;
|
|
}
|
|
|
|
static void user_dlm_recovery_handler_noop(int node_num,
|
|
void *recovery_data)
|
|
{
|
|
/* We ignore recovery events */
|
|
return;
|
|
}
|
|
|
|
void user_dlm_set_locking_protocol(void)
|
|
{
|
|
ocfs2_stack_glue_set_max_proto_version(&user_dlm_lproto.lp_max_version);
|
|
}
|
|
|
|
struct ocfs2_cluster_connection *user_dlm_register(const struct qstr *name)
|
|
{
|
|
int rc;
|
|
struct ocfs2_cluster_connection *conn;
|
|
|
|
rc = ocfs2_cluster_connect_agnostic(name->name, name->len,
|
|
&user_dlm_lproto,
|
|
user_dlm_recovery_handler_noop,
|
|
NULL, &conn);
|
|
if (rc)
|
|
mlog_errno(rc);
|
|
|
|
return rc ? ERR_PTR(rc) : conn;
|
|
}
|
|
|
|
void user_dlm_unregister(struct ocfs2_cluster_connection *conn)
|
|
{
|
|
ocfs2_cluster_disconnect(conn, 0);
|
|
}
|