From patchwork Wed Oct 21 21:39:23 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Benjamin Marzinski X-Patchwork-Id: 11849841 X-Patchwork-Delegate: christophe.varoqui@free.fr Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id AEFEAC4363A for ; Wed, 21 Oct 2020 21:42:01 +0000 (UTC) Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [63.128.21.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id F381C2417D for ; Wed, 21 Oct 2020 21:42:00 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="PH9epMnX" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org F381C2417D Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=tempfail smtp.mailfrom=dm-devel-bounces@redhat.com DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1603316519; h=from:from:sender:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:list-id:list-help: list-unsubscribe:list-subscribe:list-post; bh=FGzlzb0Ed2YKbLJ/M7wPhceFbcVkX/sFkqVRWRRJx1I=; b=PH9epMnXwd9YjZXtQaTKe9wdiKhtK7HNl9kYUZpkFzZN5maUNF0nA7XDePtQiC7b5aSbcJ KGWezjOYLSotchsGZlh27rNO4dIEFBC1tWy6Z9P6nzU89B8CiS/0Gm+UtShjjUp5KzkoT0 q/p4DyWwyupZ1liiJSWUZtU8sX8nhd8= Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-366-Dlddb1idPFyNgfIBkhD7Mg-1; Wed, 21 Oct 2020 17:41:57 -0400 X-MC-Unique: Dlddb1idPFyNgfIBkhD7Mg-1 Received: from smtp.corp.redhat.com (int-mx07.intmail.prod.int.phx2.redhat.com [10.5.11.22]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id CBE76107AFA5; Wed, 21 Oct 2020 21:41:52 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.21]) by smtp.corp.redhat.com (Postfix) with ESMTPS id ADB5E1002C01; Wed, 21 Oct 2020 21:41:52 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id 8598F8C7DE; Wed, 21 Oct 2020 21:41:52 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id 09LLdXU7008765 for ; Wed, 21 Oct 2020 17:39:33 -0400 Received: by smtp.corp.redhat.com (Postfix) id 207A85B4A1; Wed, 21 Oct 2020 21:39:33 +0000 (UTC) Received: from octiron.msp.redhat.com (octiron.msp.redhat.com [10.15.80.209]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 710615B4BC; Wed, 21 Oct 2020 21:39:29 +0000 (UTC) Received: from octiron.msp.redhat.com (localhost.localdomain [127.0.0.1]) by octiron.msp.redhat.com (8.14.9/8.14.9) with ESMTP id 09LLdS3P028779; Wed, 21 Oct 2020 16:39:28 -0500 Received: (from bmarzins@localhost) by octiron.msp.redhat.com (8.14.9/8.14.9/Submit) id 09LLdR1M028778; Wed, 21 Oct 2020 16:39:27 -0500 From: Benjamin Marzinski To: Christophe Varoqui Date: Wed, 21 Oct 2020 16:39:23 -0500 Message-Id: <1603316366-28735-2-git-send-email-bmarzins@redhat.com> In-Reply-To: <1603316366-28735-1-git-send-email-bmarzins@redhat.com> References: <1603316366-28735-1-git-send-email-bmarzins@redhat.com> X-Scanned-By: MIMEDefang 2.79 on 10.5.11.11 X-loop: dm-devel@redhat.com Cc: device-mapper development , Martin Wilck Subject: [dm-devel] [PATCH v3 1/4] multipath: add libmpathvalid library X-BeenThere: dm-devel@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: device-mapper development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Sender: dm-devel-bounces@redhat.com Errors-To: dm-devel-bounces@redhat.com X-Scanned-By: MIMEDefang 2.84 on 10.5.11.22 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=dm-devel-bounces@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com This library allows other programs to check if a path should be claimed by multipath. It exports an init function, that needs to be called before and after all other library calls, an exit function, that needs to be called after all library calls, a function to reread the multipath configuration files, and two more functions. mpath_get_mode() get the configured find_multipaths mode. mpath_is_path() returns whether the device is claimed by multipath, and optionally returns the wwid. This code works slightly different than the multipath -c/u code for SMART mode. Instead of checking all the existing paths to see if another has the same wwid, it expects the caller to pass in an array of the already known path wwids, and checks if the current path matches any of those. The library also doesn't set up the device-mapper library. It leaves this up to the caller. Signed-off-by: Benjamin Marzinski --- Makefile | 3 +- libmpathvalid/Makefile | 39 ++++++ libmpathvalid/libmpathvalid.version | 10 ++ libmpathvalid/mpath_valid.c | 202 ++++++++++++++++++++++++++++ libmpathvalid/mpath_valid.h | 155 +++++++++++++++++++++ libmultipath/libmultipath.version | 6 + 6 files changed, 414 insertions(+), 1 deletion(-) create mode 100644 libmpathvalid/Makefile create mode 100644 libmpathvalid/libmpathvalid.version create mode 100644 libmpathvalid/mpath_valid.c create mode 100644 libmpathvalid/mpath_valid.h diff --git a/Makefile b/Makefile index 4a3491da..f127ff91 100644 --- a/Makefile +++ b/Makefile @@ -9,6 +9,7 @@ BUILDDIRS := \ libmultipath/checkers \ libmultipath/foreign \ libmpathpersist \ + libmpathvalid \ multipath \ multipathd \ mpathpersist \ @@ -29,7 +30,7 @@ $(BUILDDIRS): $(MAKE) -C $@ libmultipath libdmmp: libmpathcmd -libmpathpersist multipath multipathd: libmultipath +libmpathpersist libmpathvalid multipath multipathd: libmultipath mpathpersist multipathd: libmpathpersist libmultipath/checkers.install \ diff --git a/libmpathvalid/Makefile b/libmpathvalid/Makefile new file mode 100644 index 00000000..6bea4bcd --- /dev/null +++ b/libmpathvalid/Makefile @@ -0,0 +1,39 @@ +include ../Makefile.inc + +SONAME = 0 +DEVLIB = libmpathvalid.so +LIBS = $(DEVLIB).$(SONAME) +VERSION_SCRIPT := libmpathvalid.version + +CFLAGS += $(LIB_CFLAGS) -I$(multipathdir) -I$(mpathcmddir) + +LIBDEPS += -lpthread -ldevmapper -ldl -L$(multipathdir) \ + -lmultipath -L$(mpathcmddir) -lmpathcmd -ludev + +OBJS = mpath_valid.o + +all: $(LIBS) + +$(LIBS): $(OBJS) $(VERSION_SCRIPT) + $(CC) $(LDFLAGS) $(SHARED_FLAGS) -Wl,-soname=$@ -o $@ $(OBJS) $(LIBDEPS) -Wl,--version-script=libmpathvalid.version + $(LN) $(LIBS) $(DEVLIB) + +install: $(LIBS) + $(INSTALL_PROGRAM) -m 755 -d $(DESTDIR)$(syslibdir) + $(INSTALL_PROGRAM) -m 755 $(LIBS) $(DESTDIR)$(syslibdir)/$(LIBS) + $(LN) $(LIBS) $(DESTDIR)$(syslibdir)/$(DEVLIB) + $(INSTALL_PROGRAM) -m 755 -d $(DESTDIR)$(includedir) + $(INSTALL_PROGRAM) -m 644 mpath_valid.h $(DESTDIR)$(includedir) + +uninstall: + $(RM) $(DESTDIR)$(syslibdir)/$(LIBS) + $(RM) $(DESTDIR)$(syslibdir)/$(DEVLIB) + $(RM) $(DESTDIR)$(includedir)/mpath_valid.h + +clean: dep_clean + $(RM) core *.a *.o *.so *.so.* *.gz + +include $(wildcard $(OBJS:.o=.d)) + +dep_clean: + $(RM) $(OBJS:.o=.d) diff --git a/libmpathvalid/libmpathvalid.version b/libmpathvalid/libmpathvalid.version new file mode 100644 index 00000000..3bd0d3c5 --- /dev/null +++ b/libmpathvalid/libmpathvalid.version @@ -0,0 +1,10 @@ +MPATH_1.0 { + global: + mpathvalid_init; + mpathvalid_reload_config; + mpathvalid_exit; + mpathvalid_is_path; + mpathvalid_get_mode; + local: + *; +}; diff --git a/libmpathvalid/mpath_valid.c b/libmpathvalid/mpath_valid.c new file mode 100644 index 00000000..7073d17d --- /dev/null +++ b/libmpathvalid/mpath_valid.c @@ -0,0 +1,202 @@ +#include +#include +#include +#include +#include +#include + +#include "devmapper.h" +#include "structs.h" +#include "util.h" +#include "config.h" +#include "discovery.h" +#include "wwids.h" +#include "sysfs.h" +#include "mpath_cmd.h" +#include "valid.h" +#include "mpath_valid.h" +#include "debug.h" + +static unsigned int +get_conf_mode(struct config *conf) +{ + if (conf->find_multipaths == FIND_MULTIPATHS_SMART) + return MPATH_SMART; + if (conf->find_multipaths == FIND_MULTIPATHS_GREEDY) + return MPATH_GREEDY; + return MPATH_STRICT; +} + +static void +set_conf_mode(struct config *conf, unsigned int mode) +{ + if (mode == MPATH_SMART) + conf->find_multipaths = FIND_MULTIPATHS_SMART; + else if (mode == MPATH_GREEDY) + conf->find_multipaths = FIND_MULTIPATHS_GREEDY; + else + conf->find_multipaths = FIND_MULTIPATHS_STRICT; +} + +unsigned int +mpathvalid_get_mode(void) +{ + int mode; + struct config *conf; + + conf = get_multipath_config(); + if (!conf) + mode = MPATH_MODE_ERROR; + else + mode = get_conf_mode(conf); + put_multipath_config(conf); + return mode; +} + +static int +convert_result(int result) { + switch (result) { + case PATH_IS_ERROR: + return MPATH_IS_ERROR; + case PATH_IS_NOT_VALID: + return MPATH_IS_NOT_VALID; + case PATH_IS_VALID: + return MPATH_IS_VALID; + case PATH_IS_VALID_NO_CHECK: + return MPATH_IS_VALID_NO_CHECK; + case PATH_IS_MAYBE_VALID: + return MPATH_IS_MAYBE_VALID; + } + return MPATH_IS_ERROR; +} + +static void +set_log_style(int log_style) +{ + /* + * convert MPATH_LOG_* to LOGSINK_* + * currently there is no work to do here. + */ + logsink = log_style; +} + +static int +load_default_config(int verbosity) +{ + /* need to set verbosity here to control logging during init_config() */ + libmp_verbosity = verbosity; + if (init_config(DEFAULT_CONFIGFILE)) + return -1; + /* Need to override verbosity from init_config() */ + libmp_verbosity = verbosity; + + return 0; +} + +int +mpathvalid_init(int verbosity, int log_style) +{ + unsigned int version[3]; + + set_log_style(log_style); + if (libmultipath_init()) + return -1; + + skip_libmp_dm_init(); + if (load_default_config(verbosity)) + goto fail; + + if (dm_prereq(version)) + goto fail_config; + + return 0; + +fail_config: + uninit_config(); +fail: + libmultipath_exit(); + return -1; +} + +int +mpathvalid_reload_config(void) +{ + uninit_config(); + return load_default_config(libmp_verbosity); +} + +int +mpathvalid_exit(void) +{ + uninit_config(); + libmultipath_exit(); + return 0; +} + +/* + * name: name of path to check + * mode: mode to use for determination. MPATH_DEFAULT uses configured mode + * info: on success, contains the path wwid + * paths: array of the returned mpath_info from other claimed paths + * nr_paths: the size of the paths array + */ +int +mpathvalid_is_path(const char *name, unsigned int mode, char **wwid, + const char **path_wwids, unsigned int nr_paths) +{ + struct config *conf; + int find_multipaths_saved, r = MPATH_IS_ERROR; + unsigned int i; + struct path *pp; + + if (!name || mode >= MPATH_MODE_ERROR) + return r; + if (nr_paths > 0 && !path_wwids) + return r; + if (!udev) + return r; + + pp = alloc_path(); + if (!pp) + return r; + + if (wwid) { + *wwid = (char *)malloc(WWID_SIZE); + if (!*wwid) + goto out; + } + + conf = get_multipath_config(); + if (!conf) + goto out_wwid; + find_multipaths_saved = conf->find_multipaths; + if (mode != MPATH_DEFAULT) + set_conf_mode(conf, mode); + r = convert_result(is_path_valid(name, conf, pp, true)); + conf->find_multipaths = find_multipaths_saved; + put_multipath_config(conf); + + if (r == MPATH_IS_MAYBE_VALID) { + for (i = 0; i < nr_paths; i++) { + if (path_wwids[i] && + strncmp(path_wwids[i], pp->wwid, WWID_SIZE) == 0) { + r = MPATH_IS_VALID; + break; + } + } + } + +out_wwid: + if (wwid) { + if (r == MPATH_IS_VALID || r == MPATH_IS_VALID_NO_CHECK || + r == MPATH_IS_MAYBE_VALID) + strlcpy(*wwid, pp->wwid, WWID_SIZE); + else { + free(*wwid); + *wwid = NULL; + } + } +out: + free_path(pp); + return r; +} diff --git a/libmpathvalid/mpath_valid.h b/libmpathvalid/mpath_valid.h new file mode 100644 index 00000000..63de4e1c --- /dev/null +++ b/libmpathvalid/mpath_valid.h @@ -0,0 +1,155 @@ +/* + * Copyright (C) 2015 Red Hat, Inc. + * + * This file is part of the device-mapper multipath userspace tools. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +#ifndef LIB_MPATH_VALID_H +#define LIB_MPATH_VALID_H + +#ifdef __cpluscplus +extern "C" { +#endif + +enum mpath_valid_mode { + MPATH_DEFAULT, + MPATH_STRICT, + MPATH_SMART, + MPATH_GREEDY, + MPATH_MODE_ERROR, +}; + +/* + * MPATH_IS_VALID_NO_CHECK is used to indicate that it is safe to skip + * checks to see if the device has already been released to the system + * for use by things other that multipath. + * MPATH_IS_MAYBE_VALID is used to indicate that this device would + * be a valid multipath path device if another device with the same + * wwid existed */ +enum mpath_valid_result { + MPATH_IS_ERROR = -1, + MPATH_IS_NOT_VALID, + MPATH_IS_VALID, + MPATH_IS_VALID_NO_CHECK, + MPATH_IS_MAYBE_VALID, +}; + +enum mpath_valid_log_style { + MPATH_LOG_STDERR = -1, /* log to STDERR */ + MPATH_LOG_STDERR_TIMESTAMP, /* log to STDERR, with timestamps */ + MPATH_LOG_SYSLOG, /* log to system log */ +}; + +enum mpath_valid_verbosity { + MPATH_LOG_PRIO_NOLOG = -1, /* log nothing */ + MPATH_LOG_PRIO_ERR, + MPATH_LOG_PRIO_WARN, + MPATH_LOG_PRIO_NOTICE, + MPATH_LOG_PRIO_INFO, + MPATH_LOG_PRIO_DEBUG, +}; + +/* Function declarations */ + +/* + * DESCRIPTION: + * Initialize the device mapper multipath configuration. This + * function must be invoked before calling any other + * libmpathvalid functions. Call mpathvalid_exit() to cleanup. + * @verbosity: the logging level (mpath_valid_verbosity) + * @log_style: the logging style (mpath_valid_log_style) + * + * RESTRICTIONS: + * Calling mpathvalid_init() after calling mpathvalid_exit() has no + * effect. + * + * RETURNS: 0 = Success, -1 = Failure + */ +int mpathvalid_init(int verbosity, int log_style); + + +/* + * DESCRIPTION: + * Reread the multipath configuration files and reinitalize + * the device mapper multipath configuration. This function can + * be called as many times as necessary. + * + * RETURNS: 0 = Success, -1 = Failure + */ +int mpathvalid_reload_config(void); + + +/* + * DESCRIPTION: + * Release the device mapper multipath configuration. This + * function must be called to cleanup resoures allocated by + * mpathvalid_init(). After calling this function, no futher + * libmpathvalid functions may be called. + * + * RETURNS: 0 = Success, -1 = Failure + */ +int mpathvalid_exit(void); + +/* + * DESCRIPTION: + * Return the configured find_multipaths claim mode, using the + * configuration from either mpathvalid_init() or + * mpathvalid_reload_config() + * + * RETURNS: + * MPATH_STRICT, MPATH_SMART, MPATH_GREEDY, or MPATH_MODE_ERROR + * + * MPATH_STRICT = find_multiapths (yes|on|no|off) + * MPATH_SMART = find_multipaths smart + * MPATH_GREEDY = find_multipaths greedy + * MPATH_MODE_ERROR = multipath configuration not initialized + */ +unsigned int mpathvalid_get_mode(void); +/* + * DESCRIPTION: + * Return whether device-mapper multipath claims a path device, + * using the configuration read from either mpathvalid_init() or + * mpathvalid_reload_config(). If the device is either claimed or + * potentially claimed (MPATH_IS_VALID, MPATH_IS_VALID_NO_CHECK, + * or MPATH_IS_MAYBE_VALID) and wwid is not NULL, then *wiid will + * be set to point to the wwid of device. If set, *wwid must be + * freed by the caller. path_wwids is an obptional parameter that + * points to an array of wwids, that were returned from previous + * calls to mpathvalid_is_path(). These are wwids of existing + * devices that are or potentially are claimed by device-mapper + * multipath. path_wwids is used with the MPATH_SMART claim mode, + * to claim devices when another device with the same wwid exists. + * nr_paths must either be set to the number of elements of + * path_wwids, or 0, if path_wwids is NULL. + * @name: The kernel name of the device. input argument + * @mode: the find_multipaths claim mode (mpath_valid_mode). input argument + * @wwid: address of a pointer to the path wwid, or NULL. Output argument. + * Set if path is/may be claimed. If set, must be freed by caller + * @path_wwids: Array of pointers to path wwids, or NULL. input argument + * @nr_paths: number of elements in path_wwids array. input argument. + * + * RETURNS: device claim result (mpath_valid_result) + * Also sets *wwid if wwid is not NULL, and the claim result is + * MPATH_IS_VALID, MPATH_IS_VALID_NO_CHECK, or + * MPATH_IS_MAYBE_VALID + */ +int mpathvalid_is_path(const char *name, unsigned int mode, char **wwid, + const char **path_wwids, unsigned int nr_paths); + +#ifdef __cplusplus +} +#endif +#endif /* LIB_PATH_VALID_H */ diff --git a/libmultipath/libmultipath.version b/libmultipath/libmultipath.version index 67a7379f..2e3583f5 100644 --- a/libmultipath/libmultipath.version +++ b/libmultipath/libmultipath.version @@ -264,3 +264,9 @@ LIBMULTIPATH_4.1.0 { global: libmp_verbosity; } LIBMULTIPATH_4.0.0; + +LIBMULTIPATH_4.2.0 { +global: + dm_prereq; + skip_libmp_dm_init; +} LIBMULTIPATH_4.1.0; From patchwork Wed Oct 21 21:39:24 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Benjamin Marzinski X-Patchwork-Id: 11849843 X-Patchwork-Delegate: christophe.varoqui@free.fr Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.9 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0D108C56201 for ; Wed, 21 Oct 2020 21:42:04 +0000 (UTC) Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [216.205.24.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 4E5CF24178 for ; Wed, 21 Oct 2020 21:42:03 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="NBiS1Vbu" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 4E5CF24178 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=tempfail smtp.mailfrom=dm-devel-bounces@redhat.com DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1603316522; h=from:from:sender:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:list-id:list-help: list-unsubscribe:list-subscribe:list-post; bh=pzE7Pbz9R0GieuLg8kIpL9qO8JpgfDMZYDvDfAIufnM=; b=NBiS1VbuF4CqPk7vQ6dmKlLX4dl+32W9dgrMb44IbWrZWzoWXlzG+RkqfHmhaLfECdW+Ba QBU1WGf2+cv4scTOgokx8Gv7hdbmH9mDzBdo/1fhfYIHdw+NWDw2j26qIBdgIf34eU5i1u rnSDLrAgdYFsubQPqSbP5pn4lFlI3jA= Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-169-DDW_n2MXO1uqcB6ocdLJsA-1; Wed, 21 Oct 2020 17:41:59 -0400 X-MC-Unique: DDW_n2MXO1uqcB6ocdLJsA-1 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id A1B878030C8; Wed, 21 Oct 2020 21:41:54 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.21]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 822405C225; Wed, 21 Oct 2020 21:41:54 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id 559CE922E9; Wed, 21 Oct 2020 21:41:54 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id 09LLdXq0008770 for ; Wed, 21 Oct 2020 17:39:33 -0400 Received: by smtp.corp.redhat.com (Postfix) id 5525E5C225; Wed, 21 Oct 2020 21:39:33 +0000 (UTC) Received: from octiron.msp.redhat.com (octiron.msp.redhat.com [10.15.80.209]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 47F415C1C7; Wed, 21 Oct 2020 21:39:30 +0000 (UTC) Received: from octiron.msp.redhat.com (localhost.localdomain [127.0.0.1]) by octiron.msp.redhat.com (8.14.9/8.14.9) with ESMTP id 09LLdTDw028783; Wed, 21 Oct 2020 16:39:29 -0500 Received: (from bmarzins@localhost) by octiron.msp.redhat.com (8.14.9/8.14.9/Submit) id 09LLdSpS028782; Wed, 21 Oct 2020 16:39:28 -0500 From: Benjamin Marzinski To: Christophe Varoqui Date: Wed, 21 Oct 2020 16:39:24 -0500 Message-Id: <1603316366-28735-3-git-send-email-bmarzins@redhat.com> In-Reply-To: <1603316366-28735-1-git-send-email-bmarzins@redhat.com> References: <1603316366-28735-1-git-send-email-bmarzins@redhat.com> X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 X-loop: dm-devel@redhat.com Cc: device-mapper development , Martin Wilck Subject: [dm-devel] [PATCH v3 2/4] multipath-tools tests: and unit tests for libmpathvalid X-BeenThere: dm-devel@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: device-mapper development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Sender: dm-devel-bounces@redhat.com Errors-To: dm-devel-bounces@redhat.com X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=dm-devel-bounces@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Signed-off-by: Benjamin Marzinski --- Makefile.inc | 1 + tests/Makefile | 5 +- tests/mpathvalid.c | 467 +++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 472 insertions(+), 1 deletion(-) create mode 100644 tests/mpathvalid.c diff --git a/Makefile.inc b/Makefile.inc index e05f3a91..13587a9f 100644 --- a/Makefile.inc +++ b/Makefile.inc @@ -66,6 +66,7 @@ libdir = $(prefix)/$(LIB)/multipath unitdir = $(prefix)/$(SYSTEMDPATH)/systemd/system mpathpersistdir = $(TOPDIR)/libmpathpersist mpathcmddir = $(TOPDIR)/libmpathcmd +mpathvaliddir = $(TOPDIR)/libmpathvalid thirdpartydir = $(TOPDIR)/third-party libdmmpdir = $(TOPDIR)/libdmmp nvmedir = $(TOPDIR)/libmultipath/nvme diff --git a/tests/Makefile b/tests/Makefile index 73ff0f5c..73ec0702 100644 --- a/tests/Makefile +++ b/tests/Makefile @@ -13,7 +13,7 @@ CFLAGS += $(BIN_CFLAGS) -I$(multipathdir) -I$(mpathcmddir) \ LIBDEPS += -L. -L$(mpathcmddir) -lmultipath -lmpathcmd -lcmocka TESTS := uevent parser util dmevents hwtable blacklist unaligned vpd pgpolicy \ - alias directio valid devt + alias directio valid devt mpathvalid .SILENT: $(TESTS:%=%.o) .PRECIOUS: $(TESTS:%=%-test) @@ -30,6 +30,7 @@ endif ifneq ($(DIO_TEST_DEV),) directio-test_FLAGS := -DDIO_TEST_DEV=\"$(DIO_TEST_DEV)\" endif +mpathvalid-test_FLAGS := -I$(mpathvaliddir) # test-specific linker flags # XYZ-test_TESTDEPS: test libraries containing __wrap_xyz functions @@ -55,6 +56,8 @@ alias-test_LIBDEPS := -lpthread -ldl valid-test_OBJDEPS := ../libmultipath/valid.o valid-test_LIBDEPS := -ludev -lpthread -ldl devt-test_LIBDEPS := -ludev +mpathvalid-test_LIBDEPS := -ludev -lpthread -ldl +mpathvalid-test_OBJDEPS := ../libmpathvalid/mpath_valid.o ifneq ($(DIO_TEST_DEV),) directio-test_LIBDEPS := -laio endif diff --git a/tests/mpathvalid.c b/tests/mpathvalid.c new file mode 100644 index 00000000..5ffabb9d --- /dev/null +++ b/tests/mpathvalid.c @@ -0,0 +1,467 @@ +/* + * Copyright (c) 2020 Benjamin Marzinski, Red Hat + * + * SPDX-License-Identifier: GPL-2.0-or-later + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include "structs.h" +#include "config.h" +#include "mpath_valid.h" +#include "util.h" +#include "debug.h" + +const char *test_dev = "test_name"; +#define TEST_WWID "WWID_123" +#define CONF_TEMPLATE "mpathvalid-testconf-XXXXXXXX" +char conf_name[] = CONF_TEMPLATE; +bool initialized; + +#if 0 +static int mode_to_findmp(unsigned int mode) +{ + switch (mode) { + case MPATH_SMART: + return FIND_MULTIPATHS_SMART; + case MPATH_GREEDY: + return FIND_MULTIPATHS_GREEDY; + case MPATH_STRICT: + return FIND_MULTIPATHS_STRICT; + } + fail_msg("invalid mode: %u", mode); + return FIND_MULTIPATHS_UNDEF; +} +#endif + +static unsigned int findmp_to_mode(int findmp) +{ + switch (findmp) { + case FIND_MULTIPATHS_SMART: + return MPATH_SMART; + case FIND_MULTIPATHS_GREEDY: + return MPATH_GREEDY; + case FIND_MULTIPATHS_STRICT: + case FIND_MULTIPATHS_OFF: + case FIND_MULTIPATHS_ON: + return MPATH_STRICT; + } + fail_msg("invalid find_multipaths value: %d", findmp); + return MPATH_DEFAULT; +} + +int __wrap_is_path_valid(const char *name, struct config *conf, struct path *pp, + bool check_multipathd) +{ + int r = mock_type(int); + int findmp = mock_type(int); + + assert_ptr_equal(name, test_dev); + assert_ptr_not_equal(conf, NULL); + assert_ptr_not_equal(pp, NULL); + assert_true(check_multipathd); + + assert_int_equal(findmp, conf->find_multipaths); + if (r == MPATH_IS_ERROR || r == MPATH_IS_NOT_VALID) + return r; + + strlcpy(pp->wwid, mock_ptr_type(char *), WWID_SIZE); + return r; +} + +int __wrap_libmultipath_init(void) +{ + int r = mock_type(int); + + assert_false(initialized); + if (r != 0) + return r; + initialized = true; + return 0; +} + +void __wrap_libmultipath_exit(void) +{ + assert_true(initialized); + initialized = false; +} + +int __wrap_dm_prereq(unsigned int *v) +{ + assert_ptr_not_equal(v, NULL); + return mock_type(int); +} + +int __real_init_config(const char *file); + +int __wrap_init_config(const char *file) +{ + int r = mock_type(int); + struct config *conf; + + assert_ptr_equal(file, DEFAULT_CONFIGFILE); + if (r != 0) + return r; + + assert_string_not_equal(conf_name, CONF_TEMPLATE); + r = __real_init_config(conf_name); + conf = get_multipath_config(); + assert_ptr_not_equal(conf, NULL); + assert_int_equal(conf->find_multipaths, mock_type(int)); + return 0; +} + +static const char * const find_multipaths_optvals[] = { + [FIND_MULTIPATHS_OFF] = "off", + [FIND_MULTIPATHS_ON] = "on", + [FIND_MULTIPATHS_STRICT] = "strict", + [FIND_MULTIPATHS_GREEDY] = "greedy", + [FIND_MULTIPATHS_SMART] = "smart", +}; + +void make_config_file(int findmp) +{ + int r, fd; + char buf[64]; + + assert_true(findmp > FIND_MULTIPATHS_UNDEF && + findmp < __FIND_MULTIPATHS_LAST); + + r = snprintf(buf, sizeof(buf), "defaults {\nfind_multipaths %s\n}\n", + find_multipaths_optvals[findmp]); + assert_true(r > 0 && (long unsigned int)r < sizeof(buf)); + + memcpy(conf_name, CONF_TEMPLATE, sizeof(conf_name)); + fd = mkstemp(conf_name); + assert_true(fd >= 0); + assert_int_equal(safe_write(fd, buf, r), 0); + assert_int_equal(close(fd), 0); +} + +int setup(void **state) +{ + initialized = false; + udev = udev_new(); + if (udev == NULL) + return -1; + return 0; +} + +int teardown(void **state) +{ + struct config *conf; + conf = get_multipath_config(); + put_multipath_config(conf); + if (conf) + uninit_config(); + if (strcmp(conf_name, CONF_TEMPLATE) != 0) + unlink(conf_name); + udev_unref(udev); + udev = NULL; + return 0; +} + +static void check_config(bool valid_config) +{ + struct config *conf; + + conf = get_multipath_config(); + put_multipath_config(conf); + if (valid_config) + assert_ptr_not_equal(conf, NULL); +} + +/* libmultipath_init fails */ +static void test_mpathvalid_init_bad1(void **state) +{ + will_return(__wrap_libmultipath_init, 1); + assert_int_equal(mpathvalid_init(MPATH_LOG_PRIO_DEBUG, + MPATH_LOG_STDERR), -1); + assert_false(initialized); + check_config(false); +} + +/* init_config fails */ +static void test_mpathvalid_init_bad2(void **state) +{ + will_return(__wrap_libmultipath_init, 0); + will_return(__wrap_init_config, 1); + assert_int_equal(mpathvalid_init(MPATH_LOG_PRIO_ERR, + MPATH_LOG_STDERR_TIMESTAMP), -1); + assert_false(initialized); + check_config(false); +} + +/* dm_prereq fails */ +static void test_mpathvalid_init_bad3(void **state) +{ + make_config_file(FIND_MULTIPATHS_STRICT); + will_return(__wrap_libmultipath_init, 0); + will_return(__wrap_init_config, 0); + will_return(__wrap_init_config, FIND_MULTIPATHS_STRICT); + will_return(__wrap_dm_prereq, 1); + assert_int_equal(mpathvalid_init(MPATH_LOG_STDERR, MPATH_LOG_PRIO_ERR), + -1); + assert_false(initialized); + check_config(false); +} + +static void check_mpathvalid_init(int findmp, int prio, int log_style) +{ + make_config_file(findmp); + will_return(__wrap_libmultipath_init, 0); + will_return(__wrap_init_config, 0); + will_return(__wrap_init_config, findmp); + will_return(__wrap_dm_prereq, 0); + assert_int_equal(mpathvalid_init(prio, log_style), 0); + assert_true(initialized); + check_config(true); + assert_int_equal(logsink, log_style); + assert_int_equal(libmp_verbosity, prio); + assert_int_equal(findmp_to_mode(findmp), mpathvalid_get_mode()); +} + +static void check_mpathvalid_exit(void) +{ + assert_int_equal(mpathvalid_exit(), 0); + assert_false(initialized); + check_config(false); +} + +static void test_mpathvalid_init_good1(void **state) +{ + check_mpathvalid_init(FIND_MULTIPATHS_OFF, MPATH_LOG_PRIO_ERR, + MPATH_LOG_STDERR_TIMESTAMP); +} + +static void test_mpathvalid_init_good2(void **state) +{ + check_mpathvalid_init(FIND_MULTIPATHS_STRICT, MPATH_LOG_PRIO_DEBUG, + MPATH_LOG_STDERR); +} + +static void test_mpathvalid_init_good3(void **state) +{ + check_mpathvalid_init(FIND_MULTIPATHS_ON, MPATH_LOG_PRIO_NOLOG, + MPATH_LOG_SYSLOG); +} + +static void test_mpathvalid_exit(void **state) +{ + check_mpathvalid_init(FIND_MULTIPATHS_ON, MPATH_LOG_PRIO_ERR, + MPATH_LOG_STDERR); + check_mpathvalid_exit(); +} + +/* fails if config hasn't been set */ +static void test_mpathvalid_get_mode_bad(void **state) +{ +#if 1 + assert_int_equal(mpathvalid_get_mode(), MPATH_MODE_ERROR); +#else + assert_int_equal(mpathvalid_get_mode(), 1); +#endif +} + +/*fails if config hasn't been set */ +static void test_mpathvalid_reload_config_bad1(void **state) +{ +#if 1 + will_return(__wrap_init_config, 1); +#endif + assert_int_equal(mpathvalid_reload_config(), -1); + check_config(false); +} + +/* init_config fails */ +static void test_mpathvalid_reload_config_bad2(void **state) +{ + check_mpathvalid_init(FIND_MULTIPATHS_ON, MPATH_LOG_PRIO_ERR, + MPATH_LOG_STDERR); + will_return(__wrap_init_config, 1); + assert_int_equal(mpathvalid_reload_config(), -1); + check_config(false); + check_mpathvalid_exit(); +} + +static void check_mpathvalid_reload_config(int findmp) +{ + assert_string_not_equal(conf_name, CONF_TEMPLATE); + unlink(conf_name); + make_config_file(findmp); + will_return(__wrap_init_config, 0); + will_return(__wrap_init_config, findmp); + assert_int_equal(mpathvalid_reload_config(), 0); + check_config(true); + assert_int_equal(findmp_to_mode(findmp), mpathvalid_get_mode()); +} + +static void test_mpathvalid_reload_config_good(void **state) +{ + check_mpathvalid_init(FIND_MULTIPATHS_OFF, MPATH_LOG_PRIO_ERR, + MPATH_LOG_STDERR); + check_mpathvalid_reload_config(FIND_MULTIPATHS_ON); + check_mpathvalid_reload_config(FIND_MULTIPATHS_GREEDY); + check_mpathvalid_reload_config(FIND_MULTIPATHS_SMART); + check_mpathvalid_reload_config(FIND_MULTIPATHS_STRICT); + check_mpathvalid_exit(); +} + +/* NULL name */ +static void test_mpathvalid_is_path_bad1(void **state) +{ + assert_int_equal(mpathvalid_is_path(NULL, MPATH_STRICT, NULL, NULL, 0), + MPATH_IS_ERROR); +} + +/* bad mode */ +static void test_mpathvalid_is_path_bad2(void **state) +{ + assert_int_equal(mpathvalid_is_path(test_dev, MPATH_MODE_ERROR, NULL, + NULL, 0), MPATH_IS_ERROR); +} + +/* NULL path_wwids and non-zero nr_paths */ +static void test_mpathvalid_is_path_bad3(void **state) +{ + assert_int_equal(mpathvalid_is_path(test_dev, MPATH_MODE_ERROR, NULL, + NULL, 1), MPATH_IS_ERROR); +} + +/*fails if config hasn't been set */ +static void test_mpathvalid_is_path_bad4(void **state) +{ +#if 0 + will_return(__wrap_is_path_valid, MPATH_IS_ERROR); + will_return(__wrap_is_path_valid, FIND_MULTIPATHS_STRICT); +#endif + assert_int_equal(mpathvalid_is_path(test_dev, MPATH_STRICT, NULL, + NULL, 0), MPATH_IS_ERROR); +} + +/* is_path_valid fails */ +static void test_mpathvalid_is_path_bad5(void **state) +{ + check_mpathvalid_init(FIND_MULTIPATHS_OFF, MPATH_LOG_PRIO_ERR, + MPATH_LOG_STDERR); + will_return(__wrap_is_path_valid, MPATH_IS_ERROR); + will_return(__wrap_is_path_valid, FIND_MULTIPATHS_GREEDY); + assert_int_equal(mpathvalid_is_path(test_dev, MPATH_GREEDY, NULL, + NULL, 0), MPATH_IS_ERROR); + check_mpathvalid_exit(); +} + +static void test_mpathvalid_is_path_good1(void **state) +{ + char *wwid; + check_mpathvalid_init(FIND_MULTIPATHS_STRICT, MPATH_LOG_PRIO_ERR, + MPATH_LOG_STDERR); + will_return(__wrap_is_path_valid, MPATH_IS_NOT_VALID); + will_return(__wrap_is_path_valid, FIND_MULTIPATHS_STRICT); + assert_int_equal(mpathvalid_is_path(test_dev, MPATH_DEFAULT, &wwid, + NULL, 0), MPATH_IS_NOT_VALID); + assert_ptr_equal(wwid, NULL); + check_mpathvalid_exit(); +} + +static void test_mpathvalid_is_path_good2(void **state) +{ + const char *wwids[] = { "WWID_A", "WWID_B", "WWID_C", "WWID_D" }; + char *wwid; + check_mpathvalid_init(FIND_MULTIPATHS_ON, MPATH_LOG_PRIO_ERR, + MPATH_LOG_STDERR); + will_return(__wrap_is_path_valid, MPATH_IS_VALID); + will_return(__wrap_is_path_valid, FIND_MULTIPATHS_ON); + will_return(__wrap_is_path_valid, TEST_WWID); + assert_int_equal(mpathvalid_is_path(test_dev, MPATH_DEFAULT, &wwid, + wwids, 4), MPATH_IS_VALID); + assert_string_equal(wwid, TEST_WWID); +} + +static void test_mpathvalid_is_path_good3(void **state) +{ + const char *wwids[] = { "WWID_A", "WWID_B", "WWID_C", "WWID_D" }; + char *wwid; + check_mpathvalid_init(FIND_MULTIPATHS_OFF, MPATH_LOG_PRIO_ERR, + MPATH_LOG_STDERR); + will_return(__wrap_is_path_valid, MPATH_IS_VALID); + will_return(__wrap_is_path_valid, FIND_MULTIPATHS_SMART); + will_return(__wrap_is_path_valid, TEST_WWID); + assert_int_equal(mpathvalid_is_path(test_dev, MPATH_SMART, &wwid, + wwids, 4), MPATH_IS_VALID); + assert_string_equal(wwid, TEST_WWID); +} + +/* mabybe valid with no matching paths */ +static void test_mpathvalid_is_path_good4(void **state) +{ + const char *wwids[] = { "WWID_A", "WWID_B", "WWID_C", "WWID_D" }; + char *wwid; + check_mpathvalid_init(FIND_MULTIPATHS_SMART, MPATH_LOG_PRIO_ERR, + MPATH_LOG_STDERR); + will_return(__wrap_is_path_valid, MPATH_IS_MAYBE_VALID); + will_return(__wrap_is_path_valid, FIND_MULTIPATHS_SMART); + will_return(__wrap_is_path_valid, TEST_WWID); + assert_int_equal(mpathvalid_is_path(test_dev, MPATH_DEFAULT, &wwid, + wwids, 4), MPATH_IS_MAYBE_VALID); + assert_string_equal(wwid, TEST_WWID); +} + +/* maybe valid with matching paths */ +static void test_mpathvalid_is_path_good5(void **state) +{ + const char *wwids[] = { "WWID_A", "WWID_B", TEST_WWID, "WWID_D" }; + char *wwid; + check_mpathvalid_init(FIND_MULTIPATHS_SMART, MPATH_LOG_PRIO_ERR, + MPATH_LOG_STDERR); + will_return(__wrap_is_path_valid, MPATH_IS_MAYBE_VALID); + will_return(__wrap_is_path_valid, FIND_MULTIPATHS_SMART); + will_return(__wrap_is_path_valid, TEST_WWID); + assert_int_equal(mpathvalid_is_path(test_dev, MPATH_DEFAULT, &wwid, + wwids, 4), MPATH_IS_VALID); + assert_string_equal(wwid, TEST_WWID); +} + +#define setup_test(name) \ + cmocka_unit_test_setup_teardown(name, setup, teardown) + +int test_mpathvalid(void) +{ + const struct CMUnitTest tests[] = { + setup_test(test_mpathvalid_init_bad1), + setup_test(test_mpathvalid_init_bad2), + setup_test(test_mpathvalid_init_bad3), + setup_test(test_mpathvalid_init_good1), + setup_test(test_mpathvalid_init_good2), + setup_test(test_mpathvalid_init_good3), + setup_test(test_mpathvalid_exit), + setup_test(test_mpathvalid_get_mode_bad), + setup_test(test_mpathvalid_reload_config_bad1), + setup_test(test_mpathvalid_reload_config_bad2), + setup_test(test_mpathvalid_reload_config_good), + setup_test(test_mpathvalid_is_path_bad1), + setup_test(test_mpathvalid_is_path_bad2), + setup_test(test_mpathvalid_is_path_bad3), + setup_test(test_mpathvalid_is_path_bad4), + setup_test(test_mpathvalid_is_path_bad5), + setup_test(test_mpathvalid_is_path_good1), + setup_test(test_mpathvalid_is_path_good2), + setup_test(test_mpathvalid_is_path_good3), + setup_test(test_mpathvalid_is_path_good4), + setup_test(test_mpathvalid_is_path_good5), + }; + return cmocka_run_group_tests(tests, NULL, NULL); +} + +int main(void) +{ + int r = 0; + + r += test_mpathvalid(); + return r; +} From patchwork Wed Oct 21 21:39:25 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Benjamin Marzinski X-Patchwork-Id: 11849831 X-Patchwork-Delegate: christophe.varoqui@free.fr Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 59DF3C4363A for ; Wed, 21 Oct 2020 21:39:48 +0000 (UTC) Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [63.128.21.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id A1419223C7 for ; Wed, 21 Oct 2020 21:39:47 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="dusP/Dsz" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org A1419223C7 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=tempfail smtp.mailfrom=dm-devel-bounces@redhat.com DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1603316386; h=from:from:sender:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:list-id:list-help: list-unsubscribe:list-subscribe:list-post; bh=THfIMiT5t6+9ciFii9BYp/Wjwu/q1Q0pXDIHVdjQskU=; b=dusP/Dsz3IjmJ4ZEO0fpGQEO6CpyBKv2IfXGaUEv4iKY3Po7OAqf0M8e76wK/OwIgBw3EV Mw8pNlcjAy36goNEPLTiCZzmuXmyaNjHAM6s34prCx9LrhJUASNTEcKz2BoDmGktc33Xlz 9/MXUKqa8KlAbRhIGI0TXQDMAdCzD3E= Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-18-aCkOxN6ZPY-dq54tAJis2w-1; Wed, 21 Oct 2020 17:39:44 -0400 X-MC-Unique: aCkOxN6ZPY-dq54tAJis2w-1 Received: from smtp.corp.redhat.com (int-mx07.intmail.prod.int.phx2.redhat.com [10.5.11.22]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id EAAC71019625; Wed, 21 Oct 2020 21:39:38 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.21]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 72A9710013D7; Wed, 21 Oct 2020 21:39:38 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id 80E048C7DE; Wed, 21 Oct 2020 21:39:37 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id 09LLdYJq008781 for ; Wed, 21 Oct 2020 17:39:34 -0400 Received: by smtp.corp.redhat.com (Postfix) id BDF1019D7C; Wed, 21 Oct 2020 21:39:34 +0000 (UTC) Received: from octiron.msp.redhat.com (octiron.msp.redhat.com [10.15.80.209]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 3020A19C78; Wed, 21 Oct 2020 21:39:31 +0000 (UTC) Received: from octiron.msp.redhat.com (localhost.localdomain [127.0.0.1]) by octiron.msp.redhat.com (8.14.9/8.14.9) with ESMTP id 09LLdTda028787; Wed, 21 Oct 2020 16:39:30 -0500 Received: (from bmarzins@localhost) by octiron.msp.redhat.com (8.14.9/8.14.9/Submit) id 09LLdTtY028786; Wed, 21 Oct 2020 16:39:29 -0500 From: Benjamin Marzinski To: Christophe Varoqui Date: Wed, 21 Oct 2020 16:39:25 -0500 Message-Id: <1603316366-28735-4-git-send-email-bmarzins@redhat.com> In-Reply-To: <1603316366-28735-1-git-send-email-bmarzins@redhat.com> References: <1603316366-28735-1-git-send-email-bmarzins@redhat.com> X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-loop: dm-devel@redhat.com Cc: device-mapper development , Martin Wilck Subject: [dm-devel] [PATCH v3 3/4] libmultipath: add uid failback for dasd devices X-BeenThere: dm-devel@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: device-mapper development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Sender: dm-devel-bounces@redhat.com Errors-To: dm-devel-bounces@redhat.com X-Scanned-By: MIMEDefang 2.84 on 10.5.11.22 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=dm-devel-bounces@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Add failback code to get the uid for dasd devices from sysfs. Copied from dasdinfo Reviewed-by: Martin Wilck Signed-off-by: Benjamin Marzinski --- libmultipath/defaults.h | 1 + libmultipath/discovery.c | 37 ++++++++++++++++++++++++++++++++++++- 2 files changed, 37 insertions(+), 1 deletion(-) diff --git a/libmultipath/defaults.h b/libmultipath/defaults.h index 39a5e415..947ba467 100644 --- a/libmultipath/defaults.h +++ b/libmultipath/defaults.h @@ -8,6 +8,7 @@ */ #define DEFAULT_UID_ATTRIBUTE "ID_SERIAL" #define DEFAULT_NVME_UID_ATTRIBUTE "ID_WWN" +#define DEFAULT_DASD_UID_ATTRIBUTE "ID_UID" #define DEFAULT_UDEVDIR "/dev" #define DEFAULT_MULTIPATHDIR "/" LIB_STRING "/multipath" #define DEFAULT_SELECTOR "service-time 0" diff --git a/libmultipath/discovery.c b/libmultipath/discovery.c index cbde3585..d7e8577f 100644 --- a/libmultipath/discovery.c +++ b/libmultipath/discovery.c @@ -1957,12 +1957,44 @@ get_vpd_uid(struct path * pp) return get_vpd_sysfs(parent, 0x83, pp->wwid, WWID_SIZE); } +/* based on code from s390-tools/dasdinfo/dasdinfo.c */ +static ssize_t dasd_get_uid(struct path *pp) +{ + struct udev_device *parent; + char value[80]; + char *p; + int i; + + parent = udev_device_get_parent_with_subsystem_devtype(pp->udev, "ccw", + NULL); + if (!parent) + return -1; + + if (sysfs_attr_get_value(parent, "uid", value, 80) < 0) + return -1; + + p = value - 1; + /* look for the 4th '.' and cut there */ + for (i = 0; i < 4; i++) { + p = index(p + 1, '.'); + if (!p) + break; + } + if (p) + *p = '\0'; + + return strlcpy(pp->wwid, value, WWID_SIZE); +} + static ssize_t uid_fallback(struct path *pp, int path_state, const char **origin) { ssize_t len = -1; - if (pp->bus == SYSFS_BUS_SCSI) { + if (pp->bus == SYSFS_BUS_CCW) { + len = dasd_get_uid(pp); + *origin = "sysfs"; + } else if (pp->bus == SYSFS_BUS_SCSI) { len = get_vpd_uid(pp); *origin = "sysfs"; if (len < 0 && path_state == PATH_UP) { @@ -2010,6 +2042,9 @@ static bool has_uid_fallback(struct path *pp) !strcmp(pp->uid_attribute, ""))) || (pp->bus == SYSFS_BUS_NVME && (!strcmp(pp->uid_attribute, DEFAULT_NVME_UID_ATTRIBUTE) || + !strcmp(pp->uid_attribute, ""))) || + (pp->bus == SYSFS_BUS_CCW && + (!strcmp(pp->uid_attribute, DEFAULT_DASD_UID_ATTRIBUTE) || !strcmp(pp->uid_attribute, "")))); } From patchwork Wed Oct 21 21:39:26 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Benjamin Marzinski X-Patchwork-Id: 11849837 X-Patchwork-Delegate: christophe.varoqui@free.fr Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.9 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 4A6A0C4363A for ; Wed, 21 Oct 2020 21:41:58 +0000 (UTC) Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [216.205.24.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id ABA93223C7 for ; Wed, 21 Oct 2020 21:41:57 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="VGNQ6INu" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org ABA93223C7 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=tempfail smtp.mailfrom=dm-devel-bounces@redhat.com DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1603316516; h=from:from:sender:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:list-id:list-help: list-unsubscribe:list-subscribe:list-post; bh=J+kMJPn7mZ7B8dwe0hCwammhCgnLAZMnU+9zCmoKb0Y=; b=VGNQ6INuzoDGQrryl5xQfSW6m2a5tQNEvhYg70M8bwDPgNab2AqZeYi4KWFMohokz6RLhn gA4HT0WH1T4KE9Im0Gosxt4jEHUAixmfrGkWxKG70Ncs6zPc4v1bRnAWzAal0YYjeqJPcS GCr33z8qFksDgpKQoR+xkWGAhRrj4x0= Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-511-B0RskObANMKoWki3NXjEgA-1; Wed, 21 Oct 2020 17:41:54 -0400 X-MC-Unique: B0RskObANMKoWki3NXjEgA-1 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 295E25F9C1; Wed, 21 Oct 2020 21:41:49 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.20]) by smtp.corp.redhat.com (Postfix) with ESMTPS id EB63C5C5AF; Wed, 21 Oct 2020 21:41:48 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id AD102181A06D; Wed, 21 Oct 2020 21:41:48 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id 09LLdXSR008760 for ; Wed, 21 Oct 2020 17:39:33 -0400 Received: by smtp.corp.redhat.com (Postfix) id 05A4B5B4C0; Wed, 21 Oct 2020 21:39:33 +0000 (UTC) Received: from octiron.msp.redhat.com (octiron.msp.redhat.com [10.15.80.209]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 1E62E5B4BE; Wed, 21 Oct 2020 21:39:32 +0000 (UTC) Received: from octiron.msp.redhat.com (localhost.localdomain [127.0.0.1]) by octiron.msp.redhat.com (8.14.9/8.14.9) with ESMTP id 09LLdU9p028791; Wed, 21 Oct 2020 16:39:30 -0500 Received: (from bmarzins@localhost) by octiron.msp.redhat.com (8.14.9/8.14.9/Submit) id 09LLdUmR028790; Wed, 21 Oct 2020 16:39:30 -0500 From: Benjamin Marzinski To: Christophe Varoqui Date: Wed, 21 Oct 2020 16:39:26 -0500 Message-Id: <1603316366-28735-5-git-send-email-bmarzins@redhat.com> In-Reply-To: <1603316366-28735-1-git-send-email-bmarzins@redhat.com> References: <1603316366-28735-1-git-send-email-bmarzins@redhat.com> X-Scanned-By: MIMEDefang 2.79 on 10.5.11.11 X-loop: dm-devel@redhat.com Cc: device-mapper development , Martin Wilck Subject: [dm-devel] [PATCH v3 4/4] libmultipath: change log level for null uid_attribute X-BeenThere: dm-devel@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: device-mapper development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Sender: dm-devel-bounces@redhat.com Errors-To: dm-devel-bounces@redhat.com X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=dm-devel-bounces@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com If uid_attribute is explicitly set to an empty string, multipath should log the uid at the default log level, since using the fallback code is the expected behavior. Signed-off-by: Benjamin Marzinski Reviewed-by:Martin Wilck --- libmultipath/discovery.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/libmultipath/discovery.c b/libmultipath/discovery.c index d7e8577f..950b1586 100644 --- a/libmultipath/discovery.c +++ b/libmultipath/discovery.c @@ -2084,8 +2084,11 @@ get_uid (struct path * pp, int path_state, struct udev_device *udev, len = strlen(pp->wwid); origin = "callout"; } else { - bool udev_available = udev && pp->uid_attribute + bool valid_uid_attr = pp->uid_attribute && *pp->uid_attribute; + bool empty_uid_attr = pp->uid_attribute + && !*pp->uid_attribute; + bool udev_available = udev && valid_uid_attr; if (udev_available) { len = get_udev_uid(pp, pp->uid_attribute, udev); @@ -2095,7 +2098,8 @@ get_uid (struct path * pp, int path_state, struct udev_device *udev, } if ((!udev_available || (len <= 0 && allow_fallback)) && has_uid_fallback(pp)) { - used_fallback = 1; + if (!udev || !empty_uid_attr) + used_fallback = 1; len = uid_fallback(pp, path_state, &origin); } }