mirror of
git://sourceware.org/git/lvm2.git
synced 2024-12-22 17:35:59 +03:00
8c87dda195
There have been two file locks used to protect lvm "global state": "ORPHANS" and "GLOBAL". Commands that used the ORPHAN flock in exclusive mode: pvcreate, pvremove, vgcreate, vgextend, vgremove, vgcfgrestore Commands that used the ORPHAN flock in shared mode: vgimportclone, pvs, pvscan, pvresize, pvmove, pvdisplay, pvchange, fullreport Commands that used the GLOBAL flock in exclusive mode: pvchange, pvscan, vgimportclone, vgscan Commands that used the GLOBAL flock in shared mode: pvscan --cache, pvs The ORPHAN lock covers the important cases of serializing the use of orphan PVs. It also partially covers the reporting of orphan PVs (although not correctly as explained below.) The GLOBAL lock doesn't seem to have a clear purpose (it may have eroded over time.) Neither lock correctly protects the VG namespace, or orphan PV properties. To simplify and correct these issues, the two separate flocks are combined into the one GLOBAL flock, and this flock is used from the locking sites that are in place for the lvmlockd global lock. The logic behind the lvmlockd (distributed) global lock is that any command that changes "global state" needs to take the global lock in ex mode. Global state in lvm is: the list of VG names, the set of orphan PVs, and any properties of orphan PVs. Reading this global state can use the global lock in sh mode to ensure it doesn't change while being reported. The locking of global state now looks like: lockd_global() previously named lockd_gl(), acquires the distributed global lock through lvmlockd. This is unchanged. It serializes distributed lvm commands that are changing global state. This is a no-op when lvmlockd is not in use. lockf_global() acquires an flock on a local file. It serializes local lvm commands that are changing global state. lock_global() first calls lockf_global() to acquire the local flock for global state, and if this succeeds, it calls lockd_global() to acquire the distributed lock for global state. Replace instances of lockd_gl() with lock_global(), so that the existing sites for lvmlockd global state locking are now also used for local file locking of global state. Remove the previous file locking calls lock_vol(GLOBAL) and lock_vol(ORPHAN). The following commands which change global state are now serialized with the exclusive global flock: pvchange (of orphan), pvresize (of orphan), pvcreate, pvremove, vgcreate, vgextend, vgremove, vgreduce, vgrename, vgcfgrestore, vgimportclone, vgmerge, vgsplit Commands that use a shared flock to read global state (and will be serialized against the prior list) are those that use process_each functions that are based on processing a list of all VG names, or all PVs. The list of all VGs or all PVs is global state and the shared lock prevents those lists from changing while the command is processing them. The ORPHAN lock previously attempted to produce an accurate listing of orphan PVs, but it was only acquired at the end of the command during the fake vg_read of the fake orphan vg. This is not when orphan PVs were determined; they were determined by elimination beforehand by processing all real VGs, and subtracting the PVs in the real VGs from the list of all PVs that had been identified during the initial scan. This is fixed by holding the single global lock in shared mode while processing all VGs to determine the list of orphan PVs.
82 lines
2.5 KiB
C
82 lines
2.5 KiB
C
/*
|
|
* Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
|
|
* Copyright (C) 2004-2011 Red Hat, Inc. All rights reserved.
|
|
*
|
|
* This file is part of LVM2.
|
|
*
|
|
* This copyrighted material is made available to anyone wishing to use,
|
|
* modify, copy, or redistribute it subject to the terms and conditions
|
|
* of the GNU Lesser General Public License v.2.1.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#ifndef _LVM_LOCKING_H
|
|
#define _LVM_LOCKING_H
|
|
|
|
#include "lib/uuid/uuid.h"
|
|
#include "lib/config/config.h"
|
|
|
|
struct logical_volume;
|
|
|
|
int init_locking(struct cmd_context *cmd, int file_locking_sysinit, int file_locking_readonly, int file_locking_ignorefail);
|
|
void fin_locking(void);
|
|
void reset_locking(void);
|
|
int vg_write_lock_held(void);
|
|
|
|
/*
|
|
* Lock/unlock on-disk volume group data.
|
|
* Use VG_GLOBAL as a global lock.
|
|
* char *vol holds volume group name.
|
|
* If more than one lock needs to be held simultaneously, they must be
|
|
* acquired in alphabetical order of 'vol' (to avoid deadlocks).
|
|
*/
|
|
int lock_vol(struct cmd_context *cmd, const char *vol, uint32_t flags, const struct logical_volume *lv);
|
|
|
|
#define LCK_TYPE_MASK 0x00000007U
|
|
#define LCK_READ 0x00000001U
|
|
#define LCK_WRITE 0x00000004U
|
|
#define LCK_UNLOCK 0x00000006U
|
|
|
|
/*
|
|
* Lock bits.
|
|
* Bottom 8 bits except LCK_LOCAL form args[0] in cluster comms.
|
|
*/
|
|
#define LCK_NONBLOCK 0x00000010U /* Don't block waiting for lock? */
|
|
#define LCK_CONVERT 0x00000020U
|
|
|
|
#define VG_ORPHANS "#orphans"
|
|
#define VG_GLOBAL "#global"
|
|
|
|
#define LCK_VG_READ LCK_READ
|
|
#define LCK_VG_WRITE LCK_WRITE
|
|
#define LCK_VG_UNLOCK LCK_UNLOCK
|
|
|
|
#define unlock_vg(cmd, vg, vol) \
|
|
do { \
|
|
if (is_real_vg(vol) && !sync_local_dev_names(cmd)) \
|
|
stack; \
|
|
if (!lock_vol(cmd, vol, LCK_VG_UNLOCK, NULL)) \
|
|
stack; \
|
|
} while (0)
|
|
#define unlock_and_release_vg(cmd, vg, vol) \
|
|
do { \
|
|
unlock_vg(cmd, vg, vol); \
|
|
release_vg(vg); \
|
|
} while (0)
|
|
|
|
int sync_local_dev_names(struct cmd_context* cmd);
|
|
|
|
/* Process list of LVs */
|
|
struct volume_group;
|
|
int activate_lvs(struct cmd_context *cmd, struct dm_list *lvs, unsigned exclusive);
|
|
|
|
int lockf_global(struct cmd_context *cmd, const char *mode);
|
|
int lockf_global_convert(struct cmd_context *cmd, const char *mode);
|
|
int lock_global(struct cmd_context *cmd, const char *mode);
|
|
int lock_global_convert(struct cmd_context *cmd, const char *mode);
|
|
|
|
#endif
|