shaba/lvm2
1
0
Fork 0
mirror of git://sourceware.org/git/lvm2.git synced 2024-12-22 17:35:59 +03:00
Code Releases Activity
b6f0f20da2
lvm2/lib/cache/lvmetad.h

214 lines
8.3 KiB
C
Raw Normal View History

The lvmetad client-side integration. Only active when use_lvmetad = 1 is set in lvm.conf *and* lvmetad is running.
2012-02-23 17:11:07 +04:00
/*
Bypass lvmetad fns when not configured to use lvmetad.
2012-02-28 22:22:52 +04:00
* Copyright (C) 2012 Red Hat, Inc.
The lvmetad client-side integration. Only active when use_lvmetad = 1 is set in lvm.conf *and* lvmetad is running.
2012-02-23 17:11:07 +04:00
*
* 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,
doc: change fsf address Hmm rpmlint suggest fsf is using a different address these days, so lets keep it up-to-date
2016-01-21 13:49:46 +03:00
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
The lvmetad client-side integration. Only active when use_lvmetad = 1 is set in lvm.conf *and* lvmetad is running.
2012-02-23 17:11:07 +04:00
*/
#ifndef _LVM_METAD_H
#define _LVM_METAD_H
build: Don't generate symlinks in include/ dir As we start refactoring the code to break dependencies (see doc/refactoring.txt), I want us to use full paths in the includes (eg, #include "base/data-struct/list.h"). This makes it more obvious when we're breaking abstraction boundaries, eg, including a file in metadata/ from base/
2018-05-14 12:30:20 +03:00
#include "libdaemon/client/config-util.h"
lib/cache/lvmetad: Refactor to use dm_config_tree in requests. We were using daemon_send_simple until now, but it is no longer adequate, since we need to manipulate requests in a generic way (adding a validity token to each request), and the tree-based request interface is much more suitable for this.
2012-08-11 12:37:28 +04:00
[lvmetad.h] Use static inline functions to stub out functions. The macros were causing warnings because the arguments were percieved as unused.
2018-02-12 16:41:27 +03:00
#include <stdint.h>
The lvmetad client-side integration. Only active when use_lvmetad = 1 is set in lvm.conf *and* lvmetad is running.
2012-02-23 17:11:07 +04:00
struct volume_group;
struct cmd_context;
struct dm_config_tree;
clenaup: compatible definition for older gcc Fixes previous commit, it seems older gcc compilers do not recognize same typedef. (Easiest would be probably to directly include proper header here).
2012-08-23 18:12:45 +04:00
enum activation_change;
The lvmetad client-side integration. Only active when use_lvmetad = 1 is set in lvm.conf *and* lvmetad is running.
2012-02-23 17:11:07 +04:00
lvmetad: Fix autoactivation for MDA-less PVs. Calling pvscan --cache with -aay on a PV without an MDA would spuriously fail with an internal error, because of an incorrect assumption that a parsed VG structure was always available. This is not true and the autoactivation handler needs to call vg_read to obtain metadata in cases where the PV had no MDAs to parse. Therefore, we pass vgid into the handler instead of the (possibly NULL) VG coming from the PV's MDA.
2012-12-12 15:51:28 +04:00
typedef int (*activation_handler) (struct cmd_context *cmd,
autoactivation: use VG read lock The activation (including the refresh) should take the VG read lock like the usual activation/refresh.
2014-03-14 15:07:41 +04:00
const char *vgname, const char *vgid,
autoactivation: issue a VG refresh before autoactivation only if 'change' lvmetad flag is set This prevents numerous VG refreshes on each "pvscan --cache -aay" call if the VG is found complete. We need to issue the refresh only if the PV: - is new - was gone before and now it reappears (device "unplug/plug back" scenario) - the metadata has changed
2014-03-14 13:44:14 +04:00
int partial, int changed,
clenaup: compatible definition for older gcc Fixes previous commit, it seems older gcc compilers do not recognize same typedef. (Easiest would be probably to directly include proper header here).
2012-08-23 18:12:45 +04:00
enum activation_change activate);
activate: add autoactivation hooks Define an 'activation_handler' that gets called automatically on PV appearance/disappearance while processing the lvmetad_pv_found and lvmetad_pv_gone functions that are supposed to update the lvmetad state based on PV availability state. For now, the actual support is for PV appearance only, leaving room for PV disappearance support as well (which is a more complex problem to solve as this needs to count with possible device stack). Add a new activation change mode - CHANGE_AAY exposed as '--activate ay/-aay' argument ('activate automatically'). Factor out the vgchange activation functionality for use in other tools (like pvscan...).
2012-06-27 16:59:34 +04:00
Bypass lvmetad fns when not configured to use lvmetad.
2012-02-28 22:22:52 +04:00
#ifdef LVMETAD_SUPPORT
The lvmetad client-side integration. Only active when use_lvmetad = 1 is set in lvm.conf *and* lvmetad is running.
2012-02-23 17:11:07 +04:00
/*
lvmetad: rework command connection setup and checking The lvmetad connection is created within the init_connections() path during command startup, rather than via the old lvmetad_active() check. The old lvmetad_active() checks are replaced with lvmetad_used() which is a simple check that tests if the command is using/connected to lvmetad. The old lvmetad_set_active(cmd, 0) calls, which stopped the command from using lvmetad (to revert to disk scanning), are replaced with lvmetad_make_unused(cmd).
2016-04-14 01:00:01 +03:00
* lvmetad_connect: connect to lvmetad
* lvmetad_disconnect: disconnect from lvmetad
* lvmetad_make_unused: disconnect from lvmetad and refresh cmd filter
* lvmetad_used: check if lvmetad is being used (i.e. is connected)
The lvmetad client-side integration. Only active when use_lvmetad = 1 is set in lvm.conf *and* lvmetad is running.
2012-02-23 17:11:07 +04:00
*/
lvmetad: rework command connection setup and checking The lvmetad connection is created within the init_connections() path during command startup, rather than via the old lvmetad_active() check. The old lvmetad_active() checks are replaced with lvmetad_used() which is a simple check that tests if the command is using/connected to lvmetad. The old lvmetad_set_active(cmd, 0) calls, which stopped the command from using lvmetad (to revert to disk scanning), are replaced with lvmetad_make_unused(cmd).
2016-04-14 01:00:01 +03:00
int lvmetad_connect(struct cmd_context *cmd);
void lvmetad_disconnect(void);
void lvmetad_make_unused(struct cmd_context *cmd);
int lvmetad_used(void);
The lvmetad client-side integration. Only active when use_lvmetad = 1 is set in lvm.conf *and* lvmetad is running.
2012-02-23 17:11:07 +04:00
Implement devices/global_filter. The global filter is applied first, and is also applied in pvscan --cache (which is called from udev rules to keep lvmetad updated). Cf. example.conf.
2012-08-13 21:44:10 +04:00
/*
* Configure the socket that lvmetad_init will use to connect to the daemon.
*/
void lvmetad_set_socket(const char *);
lv/vgchange: do not try to connect to lvmetad if socket absent and --sysinit -aay used If using lv/vgchange --sysinit -aay and lvmetad is enabled, we'd like to avoid the direct activation and rely on autoactivation instead so it fits system initialization scripts. But if we're calling lv/vgchange --sysinit -aay too early when even lvmetad service is not started yet, we just need to do the direct activation instead without printing any error messages (while trying to connect to lvmetad and not finding its socket). This patch adds two helper functions - "lvmetad_socket_present" and "lvmetad_used" which can be used to check for this condition properly and avoid these lvmetad connections when the socket is not present (and hence lvmetad is not yet running).
2013-11-26 17:51:23 +04:00
/*
* Check if lvmetad socket is present (either the one set by lvmetad_set_socket
lvmetad: rework command connection setup and checking The lvmetad connection is created within the init_connections() path during command startup, rather than via the old lvmetad_active() check. The old lvmetad_active() checks are replaced with lvmetad_used() which is a simple check that tests if the command is using/connected to lvmetad. The old lvmetad_set_active(cmd, 0) calls, which stopped the command from using lvmetad (to revert to disk scanning), are replaced with lvmetad_make_unused(cmd).
2016-04-14 01:00:01 +03:00
* or the default one if not set).
lv/vgchange: do not try to connect to lvmetad if socket absent and --sysinit -aay used If using lv/vgchange --sysinit -aay and lvmetad is enabled, we'd like to avoid the direct activation and rely on autoactivation instead so it fits system initialization scripts. But if we're calling lv/vgchange --sysinit -aay too early when even lvmetad service is not started yet, we just need to do the direct activation instead without printing any error messages (while trying to connect to lvmetad and not finding its socket). This patch adds two helper functions - "lvmetad_socket_present" and "lvmetad_used" which can be used to check for this condition properly and avoid these lvmetad connections when the socket is not present (and hence lvmetad is not yet running).
2013-11-26 17:51:23 +04:00
*/
int lvmetad_socket_present(void);
lvmetad: check pid for warning case When command is not using lvmetad because use_lvmetad=0 in the config, but the lvmetad pidfile exists, print a warning (previously this checked for the socket existing instead of the pidfile existing.)
2016-04-21 17:50:59 +03:00
/*
* Check if lvmetad pidfile is present, indicating that the lvmetad
* process is running or not.
*/
int lvmetad_pidfile_present(void);
Implement devices/global_filter. The global filter is applied first, and is also applied in pvscan --cache (which is called from udev rules to keep lvmetad updated). Cf. example.conf.
2012-08-13 21:44:10 +04:00
/*
* Set the "lvmetad validity token" (currently only consists of the lvmetad
* filter. See lvm.conf.
*/
void lvmetad_set_token(const struct dm_config_value *filter);
lvmetead: release token Release allocated memory when destroing toolcontext
2012-10-12 18:50:38 +04:00
/*
* Release allocated token.
*/
void lvmetad_release_token(void);
lvmetad: fix format1 updates fmt1 doesn't have a separate commit function: updates take effect immediately vg_write is called, so we must update lvmetad at this point if we're going to go on and ask lvmetad for the VG metadata again before calling the commit function (though that's probably an unsupported and pointless thing to do anyway as the client must already have that data and it cannot have changed because it's locked and with devs suspended we shouldn't be communicating with lvmetad; so when that's fixed properly, this fix here can be reverted). This problem showed up as an internal error when lvremoving an LVM1 snapshot. > Internal error: LV snap1 (00000000000000000000000000000001) missing from preload metadata https://bugzilla.redhat.com/891855
2013-01-05 07:07:43 +04:00
// FIXME What's described here doesn't appear to be implemented yet.
The lvmetad client-side integration. Only active when use_lvmetad = 1 is set in lvm.conf *and* lvmetad is running.
2012-02-23 17:11:07 +04:00
/*
* Send a new version of VG metadata to lvmetad. This is normally called after
* vg_write but before vg_commit. After vg_commit, lvmetad_vg_commit is called
* to seal the transaction. The result of lvmetad_vg_update is that the new
* metadata is stored tentatively in lvmetad, but it is not used until
* lvmetad_vg_commit. The request is validated immediately and lvmetad_vg_commit
* only constitutes a pointer update.
*/
lvmetad: two phase vg_update Previously, a command sent lvmetad new VG metadata in vg_commit(). In vg_commit(), devices are suspended, so any memory allocation done by the command while sending to lvmetad, or by lvmetad while updating its cache could deadlock if memory reclaim was triggered. Now lvmetad is updated in unlock_vg(), after devices are resumed. The new method for updating VG metadata in lvmetad is in two phases: 1. In vg_write(), before devices are suspended, the command sends lvmetad a short message ("set_vg_info") telling it what the new VG seqno will be. lvmetad sees that the seqno is newer than the seqno of its cached VG, so it sets the INVALID flag for the cached VG. If sending the message to lvmetad fails, the command fails before the metadata is committed and the change is not made. If sending the message succeeds, vg_commit() is called. 2. In unlock_vg(), after devices are resumed, the command sends lvmetad the standard vg_update message with the new metadata. lvmetad sees that the seqno in the new metadata matches the seqno it saved from set_vg_info, and knows it has the latest copy, so it clears the INVALID flag for the cached VG. If a command fails between 1 and 2 (after committing the VG on disk, but before sending lvmetad the new metadata), the cached VG retains the INVALID flag in lvmetad. A subsequent command will read the cached VG from lvmetad, see the INVALID flag, ignore the cached copy, read the VG from disk instead, update the lvmetad copy with the latest copy from disk, (this clears the INVALID flag in lvmetad), and use the correct VG metadata for the command. (This INVALID mechanism already existed for use by lvmlockd.)
2016-06-08 22:42:03 +03:00
int lvmetad_vg_update_pending(struct volume_group *vg);
int lvmetad_vg_update_finish(struct volume_group *vg);
The lvmetad client-side integration. Only active when use_lvmetad = 1 is set in lvm.conf *and* lvmetad is running.
2012-02-23 17:11:07 +04:00
/*
* Inform lvmetad that a VG has been removed. This is not entirely safe, but is
* only needed during vgremove, which does not wipe PV labels and therefore
* cannot mark the PVs as gone.
*/
lvmetad: two phase vg_remove Apply the same idea as vg_update. Before doing the VG remove on disk, invalidate the VG in lvmetad. After the VG is removed, remove the VG in lvmetad. If the command fails after removing the VG on disk, but before removing the VG metadata from lvmetad, then a subsequent command will see the INVALID flag and not use the stale metadata from lvmetad.
2016-06-09 00:02:45 +03:00
int lvmetad_vg_remove_pending(struct volume_group *vg);
int lvmetad_vg_remove_finish(struct volume_group *vg);
The lvmetad client-side integration. Only active when use_lvmetad = 1 is set in lvm.conf *and* lvmetad is running.
2012-02-23 17:11:07 +04:00
/*
* Notify lvmetad that a PV has been found. It is not an error if the PV is
* already marked as present in lvmetad. If a non-NULL vg pointer is supplied,
* it is taken to represent the metadata read from the MDA(s) present on that
* PV. It *is* an error if: the VG is already known to lvmetad, the sequence
* number on the cached and on the discovered PV match but the metadata content
* does not.
*/
pvscan: use process_each_vg for autoactivate This refactors the code for autoactivation. Previously, as each PV was found, it would be sent to lvmetad, and the VG would be autoactivated using a non-standard VG processing function (the "activation_handler") called via a function pointer from within the lvmetad notification path. Now, any scanning that the command needs to do (scanning only the named device args, or scanning all devices when there are no args), is done first, before any activation is attempted. During the scans, the VG names are saved. After scanning is complete, process_each_vg is used to do autoactivation of the saved VG names. This makes pvscan activation much more similar to activation done with vgchange or lvchange. The separate autoactivate phase also means that if lvmetad is disabled (either before or during the scan), the command can continue with the activation step by simply not using lvmetad and reverting to disk scanning to do the activation.
2016-04-28 17:37:03 +03:00
int lvmetad_pv_found(struct cmd_context *cmd, const struct id *pvid, struct device *dev,
The lvmetad client-side integration. Only active when use_lvmetad = 1 is set in lvm.conf *and* lvmetad is running.
2012-02-23 17:11:07 +04:00
const struct format_type *fmt, uint64_t label_sector,
pvscan: use process_each_vg for autoactivate This refactors the code for autoactivation. Previously, as each PV was found, it would be sent to lvmetad, and the VG would be autoactivated using a non-standard VG processing function (the "activation_handler") called via a function pointer from within the lvmetad notification path. Now, any scanning that the command needs to do (scanning only the named device args, or scanning all devices when there are no args), is done first, before any activation is attempted. During the scans, the VG names are saved. After scanning is complete, process_each_vg is used to do autoactivation of the saved VG names. This makes pvscan activation much more similar to activation done with vgchange or lvchange. The separate autoactivate phase also means that if lvmetad is disabled (either before or during the scan), the command can continue with the activation step by simply not using lvmetad and reverting to disk scanning to do the activation.
2016-04-28 17:37:03 +03:00
struct volume_group *vg,
struct dm_list *found_vgnames,
struct dm_list *changed_vgnames);
The lvmetad client-side integration. Only active when use_lvmetad = 1 is set in lvm.conf *and* lvmetad is running.
2012-02-23 17:11:07 +04:00
/*
Scan all devices for lvmetad if 'pvscan --cache' used without device list.
2012-03-03 22:32:53 +04:00
* Inform the daemon that the device no longer exists.
The lvmetad client-side integration. Only active when use_lvmetad = 1 is set in lvm.conf *and* lvmetad is running.
2012-02-23 17:11:07 +04:00
*/
pvscan: use process_each_vg for autoactivate This refactors the code for autoactivation. Previously, as each PV was found, it would be sent to lvmetad, and the VG would be autoactivated using a non-standard VG processing function (the "activation_handler") called via a function pointer from within the lvmetad notification path. Now, any scanning that the command needs to do (scanning only the named device args, or scanning all devices when there are no args), is done first, before any activation is attempted. During the scans, the VG names are saved. After scanning is complete, process_each_vg is used to do autoactivation of the saved VG names. This makes pvscan activation much more similar to activation done with vgchange or lvchange. The separate autoactivate phase also means that if lvmetad is disabled (either before or during the scan), the command can continue with the activation step by simply not using lvmetad and reverting to disk scanning to do the activation.
2016-04-28 17:37:03 +03:00
int lvmetad_pv_gone(dev_t devno, const char *pv_name);
int lvmetad_pv_gone_by_dev(struct device *dev);
The lvmetad client-side integration. Only active when use_lvmetad = 1 is set in lvm.conf *and* lvmetad is running.
2012-02-23 17:11:07 +04:00
/*
* Request a list of all PVs available to lvmetad. If requested, this will also
* read labels off all the PVs to populate lvmcache.
*/
int lvmetad_pv_list_to_lvmcache(struct cmd_context *cmd);
Pass struct device around internally rather than dev_t. Add 3rd daemon return state "unknown" for lookups that are carried out successfully but don't find the item requested. Avoid issuing error messages when it's expected that a device that's being looked up in lvmetad might not be there.
2012-03-03 00:46:36 +04:00
/*
* Lookup an individual PV.
* If found is not NULL, it is set according to whether or not the PV is found,
* otherwise if the PV is not found an error is returned.
*/
int lvmetad_pv_lookup(struct cmd_context *cmd, struct id pvid, int *found);
int lvmetad_pv_lookup_by_dev(struct cmd_context *cmd, struct device *dev, int *found);
The lvmetad client-side integration. Only active when use_lvmetad = 1 is set in lvm.conf *and* lvmetad is running.
2012-02-23 17:11:07 +04:00
/*
* Request a list of all VGs available to lvmetad and use it to fill in
* lvmcache..
*/
int lvmetad_vg_list_to_lvmcache(struct cmd_context *cmd);
toollib: avoid repeated lvmetad vg_lookup In process_each_{vg,lv,pv} when no vgname args are given, the first step is to get a list of all vgid/vgname on the system. This is exactly what lvmetad returns from a vg_list request. The current code is doing a vg_lookup on each VG after the vg_list and populating lvmcache with the info for each VG. These preliminary vg_lookup's are unnecessary, because they will be done again when the processing functions call vg_read. This patch eliminates the initial round of vg_lookup's, which can roughly cut in half the number of lvmetad requests and save a lot of extra work.
2015-05-06 00:24:50 +03:00
/*
* Request a list of vgid/vgname pairs for all VGs known to lvmetad.
* Does not do vg_lookup's on each VG, and does not populate lvmcache.
*/
int lvmetad_get_vgnameids(struct cmd_context *cmd, struct dm_list *vgnameids);
A bit of documentation for lvmetad_vg_lookup.
2012-02-26 12:50:13 +04:00
/*
* Find a VG by its ID or its name in the lvmetad cache. Gives NULL if the VG is
* not found.
*/
struct volume_group *lvmetad_vg_lookup(struct cmd_context *cmd,
const char *vgname, const char *vgid);
The lvmetad client-side integration. Only active when use_lvmetad = 1 is set in lvm.conf *and* lvmetad is running.
2012-02-23 17:11:07 +04:00
/*
Scan all devices for lvmetad if 'pvscan --cache' used without device list.
2012-03-03 22:32:53 +04:00
* Scan a single device and update lvmetad with the result(s).
The lvmetad client-side integration. Only active when use_lvmetad = 1 is set in lvm.conf *and* lvmetad is running.
2012-02-23 17:11:07 +04:00
*/
lib/cache/lvmetad: s/pvscan_lvmetad/lvmetad_pvscan/ in the API
2012-09-10 00:05:59 +04:00
int lvmetad_pvscan_single(struct cmd_context *cmd, struct device *dev,
pvscan: use process_each_vg for autoactivate This refactors the code for autoactivation. Previously, as each PV was found, it would be sent to lvmetad, and the VG would be autoactivated using a non-standard VG processing function (the "activation_handler") called via a function pointer from within the lvmetad notification path. Now, any scanning that the command needs to do (scanning only the named device args, or scanning all devices when there are no args), is done first, before any activation is attempted. During the scans, the VG names are saved. After scanning is complete, process_each_vg is used to do autoactivation of the saved VG names. This makes pvscan activation much more similar to activation done with vgchange or lvchange. The separate autoactivate phase also means that if lvmetad is disabled (either before or during the scan), the command can continue with the activation step by simply not using lvmetad and reverting to disk scanning to do the activation.
2016-04-28 17:37:03 +03:00
struct dm_list *found_vgnames,
struct dm_list *changed_vgnames);
The lvmetad client-side integration. Only active when use_lvmetad = 1 is set in lvm.conf *and* lvmetad is running.
2012-02-23 17:11:07 +04:00
pvscan: use process_each_vg for autoactivate This refactors the code for autoactivation. Previously, as each PV was found, it would be sent to lvmetad, and the VG would be autoactivated using a non-standard VG processing function (the "activation_handler") called via a function pointer from within the lvmetad notification path. Now, any scanning that the command needs to do (scanning only the named device args, or scanning all devices when there are no args), is done first, before any activation is attempted. During the scans, the VG names are saved. After scanning is complete, process_each_vg is used to do autoactivation of the saved VG names. This makes pvscan activation much more similar to activation done with vgchange or lvchange. The separate autoactivate phase also means that if lvmetad is disabled (either before or during the scan), the command can continue with the activation step by simply not using lvmetad and reverting to disk scanning to do the activation.
2016-04-28 17:37:03 +03:00
int lvmetad_pvscan_all_devs(struct cmd_context *cmd, int do_wait);
Implement devices/global_filter. The global filter is applied first, and is also applied in pvscan --cache (which is called from udev rules to keep lvmetad updated). Cf. example.conf.
2012-08-13 21:44:10 +04:00
metadata: When outdated PVs are wiped, notify lvmetad about the fact.
2015-06-10 17:27:12 +03:00
int lvmetad_vg_clear_outdated_pvs(struct volume_group *vg);
Reread global state the lvmetad copy is stale This is the client side handling of the global_invalid state added to lvmetad in commit c595b50cec8a6b95c6ac4988912d1412f3cc0237. The function added here: . checks if the global state in lvmetad is invalid . if so, scans disks to update the state in lvmetad . clears the global_invalid flag in lvmetad . updates the local udev db to reflect any changes
2014-11-07 21:51:42 +03:00
void lvmetad_validate_global_cache(struct cmd_context *cmd, int force);
lvmetad: preemptively check and rescan in commands Move checking the lvmetad state, and the possible rescan, out of lvmetad_send() to the start of the command. Previously, the token mismatch and rescan would occur within lvmetad_send() for some other request. Now, the token mismatch is detected earlier, so the rescan can be done before the main command is in progress. Rescanning deep within the processing of another command will disturb the lvmcache state of that other command. A rescan already exists at the start of the command for the case where foreign VGs are going to be read. This same rescan is now also performed when there is an lvmetad token mismatch (from a changed global_filter). The commands pvscan/vgscan/lvscan/vgimport are excluded from this preemptive checking/rescanning for lvmetad because they want to do rescanning themselves explicitly. If rescanning devices fails, then lvmetad has not been correctly repopulated and should not be used, so make the command revert to not using lvmetad.
2016-01-29 01:40:26 +03:00
int lvmetad_token_matches(struct cmd_context *cmd);
metadata: When outdated PVs are wiped, notify lvmetad about the fact.
2015-06-10 17:27:12 +03:00
lvmcache: new function to check if VG is foreign When not using lvmetad, this uses the system_id field in the cached vginfo structs that are populated during a scan. When using lvmetad, this requests the VG from lvmetad, and checks the system_id field in the returned metadata.
2015-11-30 20:54:56 +03:00
int lvmetad_vg_is_foreign(struct cmd_context *cmd, const char *vgname, const char *vgid);
lvmetad: add disabled state A global flag in lvmetad indicates it has been disabled. Other flags indicate the reason it was disabled. These flags can be queried using get_global_info. The lvmetactl debugging utility can set and clear the disabled flag in lvmetad. Nothing else sets the disabled flag yet. Commands will check these flags after connecting to lvmetad. If the disabled flag is set, the command will not use the lvmetad cache, but revert to disk scanning. To test this feature: $ lvmetactl get_global_info response = "OK" global_invalid = 0 global_disable = 0 disable_reason = "none" token = "filter:3041577944" $ vgs (should report VGs from lvmetad) $ lvmetactl set_global_disable 1 $ lvmetactl get_global_info response = "OK" global_invalid = 0 global_disable = 1 disable_reason = "DIRECT" token = "filter:3041577944" $ vgs WARNING: Not using lvmetad because the disable flag was set directly. (should report VGs without contacting lvmetad) $ lvmetactl set_global_disable 0 $ vgs (should report VGs from lvmetad)
2016-01-29 01:54:36 +03:00
int lvmetad_is_disabled(struct cmd_context *cmd, const char **reason);
lvmetad: set disabled flag in lvmetad if lvm1 metadata is found When devices are being scanned, if lvm1 metadata is seen, tell lvmetad to set its disabled flag because of lvm1 metadata.
2016-01-29 20:30:57 +03:00
void lvmetad_set_disabled(struct cmd_context *cmd, const char *reason);
lvmetad: clear the disabled flag in lvmetad After a device rescan that repopulates lvmetad, if no reason for disabling lvmetad was seen (lvm1 metadata or duplicate PVs), then clear the disabled flag in lvmetad. This allows commands to resume using the lvmetad cache after the cause for disabling it has been removed.
2016-04-06 23:37:52 +03:00
void lvmetad_clear_disabled(struct cmd_context *cmd);
lvmetad: add disabled state A global flag in lvmetad indicates it has been disabled. Other flags indicate the reason it was disabled. These flags can be queried using get_global_info. The lvmetactl debugging utility can set and clear the disabled flag in lvmetad. Nothing else sets the disabled flag yet. Commands will check these flags after connecting to lvmetad. If the disabled flag is set, the command will not use the lvmetad cache, but revert to disk scanning. To test this feature: $ lvmetactl get_global_info response = "OK" global_invalid = 0 global_disable = 0 disable_reason = "none" token = "filter:3041577944" $ vgs (should report VGs from lvmetad) $ lvmetactl set_global_disable 1 $ lvmetactl get_global_info response = "OK" global_invalid = 0 global_disable = 1 disable_reason = "DIRECT" token = "filter:3041577944" $ vgs WARNING: Not using lvmetad because the disable flag was set directly. (should report VGs without contacting lvmetad) $ lvmetactl set_global_disable 0 $ vgs (should report VGs from lvmetad)
2016-01-29 01:54:36 +03:00
Bypass lvmetad fns when not configured to use lvmetad.
2012-02-28 22:22:52 +04:00
# else /* LVMETAD_SUPPORT */
[lvmetad.h] Use static inline functions to stub out functions. The macros were causing warnings because the arguments were percieved as unused.
2018-02-12 16:41:27 +03:00
static inline int lvmetad_connect(struct cmd_context *cmd) {return 0;}
static inline void lvmetad_disconnect(void) {}
static inline void lvmetad_make_unused(struct cmd_context *cmd) {}
static inline int lvmetad_used(void) {return 0;}
static inline void lvmetad_set_socket(const char *thing) {}
static inline int lvmetad_socket_present(void) {return 0;}
static inline int lvmetad_pidfile_present(void) {return 0;}
static inline void lvmetad_set_token(const struct dm_config_value *filter) {}
static inline void lvmetad_release_token(void) {}
static inline int lvmetad_vg_update_pending(struct volume_group *vg) {return 1;}
static inline int lvmetad_vg_update_finish(struct volume_group *vg) {return 1;}
static inline int lvmetad_vg_remove_pending(struct volume_group *vg) {return 1;}
static inline int lvmetad_vg_remove_finish(struct volume_group *vg) {return 1;}
static inline int lvmetad_pv_found(struct cmd_context *cmd, const struct id *pvid, struct device *dev,
const struct format_type *fmt, uint64_t label_sector,
struct volume_group *vg,
struct dm_list *found_vgnames,
struct dm_list *changed_vgnames) {return 1;}
static inline int lvmetad_pv_gone(dev_t devno, const char *pv_name) {return 1;}
static inline int lvmetad_pv_gone_by_dev(struct device *dev) {return 1;}
static inline int lvmetad_pv_list_to_lvmcache(struct cmd_context *cmd) {return 1;}
static inline int lvmetad_pv_lookup(struct cmd_context *cmd, struct id pvid, int *found) {return 0;}
static inline int lvmetad_pv_lookup_by_dev(struct cmd_context *cmd, struct device *dev, int *found) {return 0;}
static inline int lvmetad_vg_list_to_lvmcache(struct cmd_context *cmd) {return 1;}
static inline int lvmetad_get_vgnameids(struct cmd_context *cmd, struct dm_list *vgnameids) {return 0;}
static inline struct volume_group *lvmetad_vg_lookup(struct cmd_context *cmd,
const char *vgname, const char *vgid) {return NULL;}
static inline int lvmetad_pvscan_single(struct cmd_context *cmd, struct device *dev,
struct dm_list *found_vgnames,
struct dm_list *changed_vgnames) {return 0;}
static inline int lvmetad_pvscan_all_devs(struct cmd_context *cmd, int do_wait) {return 0;}
static inline int lvmetad_vg_clear_outdated_pvs(struct volume_group *vg) {return 0;}
static inline void lvmetad_validate_global_cache(struct cmd_context *cmd, int force) {}
static inline int lvmetad_token_matches(struct cmd_context *cmd) {return 1;}
static inline int lvmetad_vg_is_foreign(struct cmd_context *cmd, const char *vgname, const char *vgid) {return 0;}
static inline int lvmetad_is_disabled(struct cmd_context *cmd, const char **reason) {return 0;}
static inline void lvmetad_set_disabled(struct cmd_context *cmd, const char *reason) {}
static inline void lvmetad_clear_disabled(struct cmd_context *cmd) {}
The lvmetad client-side integration. Only active when use_lvmetad = 1 is set in lvm.conf *and* lvmetad is running.
2012-02-23 17:11:07 +04:00
Bypass lvmetad fns when not configured to use lvmetad.
2012-02-28 22:22:52 +04:00
# endif /* LVMETAD_SUPPORT */
#endif
Copy Permalink