{title}

); if section is defined, else just show # the command. [macros] (?su)[\\]?(?PlinkUTILITY):(?P\S*?)\[(?P.*?)\]= [attributes] asterisk=* plus=+ caret=^ startsb=[ endsb=] tilde=~ ifdef::backend-docbook[] [linkUTILITY-inlinemacro] {0%{target}} {0#} {0#{target}{0}} {0#} endif::backend-docbook[] ifdef::backend-docbook[] ifndef::UTILITY-asciidoc-no-roff[] # "unbreak" docbook-xsl v1.68 for manpages. v1.69 works with or without this. # v1.72 breaks with this because it replaces dots not in roff requests. [listingblock] {title} ifdef::doctype-manpage[] .ft C endif::doctype-manpage[] | ifdef::doctype-manpage[] .ft endif::doctype-manpage[] {title#} endif::UTILITY-asciidoc-no-roff[] ifdef::UTILITY-asciidoc-no-roff[] ifdef::doctype-manpage[] # The following two small workarounds insert a simple paragraph after screen [listingblock] {title} | {title#} [verseblock] {title} {title%} {title#} | {title#} {title%} endif::doctype-manpage[] endif::UTILITY-asciidoc-no-roff[] endif::backend-docbook[] ifdef::doctype-manpage[] ifdef::backend-docbook[] [header] template::[header-declarations] {mantitle} {manvolnum} UTILITY {UTILITY_version} UTILITY Manual {manname} {manpurpose} endif::backend-docbook[] endif::doctype-manpage[] ifdef::backend-xhtml11[] [linkUTILITY-inlinemacro] {target}{0?({0})} endif::backend-xhtml11[] ndctl-61.2/Documentation/asciidoctor-extensions.rb.in000066400000000000000000000016341331777607200230320ustar00rootroot00000000000000require 'asciidoctor' require 'asciidoctor/extensions' module @Utility@ module Documentation class Link@Utility@Processor < Asciidoctor::Extensions::InlineMacroProcessor use_dsl named :chrome def process(parent, target, attrs) if parent.document.basebackend? 'html' prefix = parent.document.attr('@utility@-relative-html-prefix') %(#{target}(#{attrs[1]})\n) elsif parent.document.basebackend? 'manpage' "#{target}(#{attrs[1]})" elsif parent.document.basebackend? 'docbook' "\n" \ "#{target}" \ "#{attrs[1]}\n" \ "\n" end end end end end Asciidoctor::Extensions.register do inline_macro @Utility@::Documentation::Link@Utility@Processor, :link@utility@ end ndctl-61.2/Documentation/copyright.txt000066400000000000000000000004471331777607200201520ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 COPYRIGHT --------- Copyright (c) 2016 - 2018, Intel Corporation. License GPLv2: GNU GPL version 2 . This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law. ndctl-61.2/Documentation/daxctl/000077500000000000000000000000001331777607200166535ustar00rootroot00000000000000ndctl-61.2/Documentation/daxctl/Makefile.am000066400000000000000000000030261331777607200207100ustar00rootroot00000000000000# Copyright(c) 2015-2017 Intel Corporation. # # This program is free software; you can redistribute it and/or modify # it under the terms of version 2 of the GNU General Public License as # published by the Free Software Foundation. # # 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 # General Public License for more details. if USE_ASCIIDOCTOR do_subst = sed -e 's,@Utility@,Daxctl,g' -e's,@utility@,daxctl,g' CONFFILE = asciidoctor-extensions.rb asciidoctor-extensions.rb: ../asciidoctor-extensions.rb.in $(AM_V_GEN) $(do_subst) < $< > $@ else do_subst = sed -e 's,UTILITY,daxctl,g' CONFFILE = asciidoc.conf asciidoc.conf: ../asciidoc.conf.in $(AM_V_GEN) $(do_subst) < $< > $@ endif man1_MANS = \ daxctl.1 \ daxctl-list.1 CLEANFILES = $(man1_MANS) XML_DEPS = \ ../../version.m4 \ ../copyright.txt \ Makefile \ $(CONFFILE) RM ?= rm -f if USE_ASCIIDOCTOR %.1: %.txt $(XML_DEPS) $(AM_V_GEN)$(RM) $@+ $@ && \ $(ASCIIDOC) -b manpage -d manpage -acompat-mode \ -I. -rasciidoctor-extensions \ -amansource=daxctl -amanmanual="daxctl Manual" \ -andctl_version=$(VERSION) -o $@+ $< && \ mv $@+ $@ else %.xml: %.txt $(XML_DEPS) $(AM_V_GEN)$(RM) $@+ $@ && \ $(ASCIIDOC) -b docbook -d manpage -f asciidoc.conf \ --unsafe -adaxctl_version=$(VERSION) -o $@+ $< && \ mv $@+ $@ %.1: %.xml $(XML_DEPS) $(AM_V_GEN)$(RM) $@ && \ $(XMLTO) -o . -m ../manpage-normal.xsl man $< endif ndctl-61.2/Documentation/daxctl/daxctl-list.txt000066400000000000000000000035631331777607200216530ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 daxctl-list(1) ============== NAME ---- daxctl-list - dump the platform Device-DAX regions, devices, and attributes in json. SYNOPSIS -------- [verse] 'daxctl list' [] Walk all the device-dax-regions in the system and list all device instances along with some of their major attributes. Options can be specified to limit the output to objects of a certain class. Where the classes are regions or devices. By default, 'daxctl list' with no options is equivalent to: [verse] daxctl list --devices EXAMPLE ------- ---- # daxctl list --regions --devices { "id":1, "devices":[ { "chardev":"dax1.0", "size":3233808384 } ] } ---- OPTIONS ------- -r:: --region=:: A device-dax region is a contiguous range of memory that hosts one or more /dev/daxX.Y devices, where X is the region id and Y is the device instance id. The keyword 'all' can be specified to carry out the operation on every region in the system. -d:: --dev=:: Specify a dax device name, . tuple, or keyword 'all' to filter the listing. For example to list the first device instance in region1: ---- # daxctl list --dev=1.0 { "chardev":"dax1.0", "size":3233808384 } ---- -D:: --devices:: Include device-dax instance info in the listing (default) -R:: --regions:: Include region info in the listing -i:: --idle:: Include idle (not enabled / zero-sized) devices in the listing -u:: --human:: By default 'daxctl list' will output machine-friendly raw-integer data. Instead, with this flag, numbers representing storage size will be formatted as human readable strings with units, other fields are converted to hexadecimal strings. Example: ---- # daxctl list { "chardev":"dax1.0", "size":32828817408 } # daxctl list --human { "chardev":"dax1.0", "size":"30.57 GiB (32.83 GB)" } ---- include::../copyright.txt[] ndctl-61.2/Documentation/daxctl/daxctl.txt000066400000000000000000000012671331777607200207010ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 daxctl(1) ========= NAME ---- daxctl - Provides enumeration and provisioning commands for the Linux kernel Device-DAX facility SYNOPSIS -------- [verse] 'daxctl' [--version] [--help] COMMAND [ARGS] OPTIONS ------- -v:: --version:: Display daxctl version. -h:: --help:: Run daxctl help command. DESCRIPTION ----------- The daxctl utility provides enumeration and provisioning commands for the Linux kernel Device-DAX facility. This facility enables DAX mappings of performance / feature differentiated memory without need of a filesystem. include::../copyright.txt[] SEE ALSO -------- linkdaxctl:ndctl-create-namespace[1], linkdaxctl:ndctl-list[1] ndctl-61.2/Documentation/manpage-base.xsl000066400000000000000000000026721331777607200204530ustar00rootroot00000000000000

ndctl-61.2/Documentation/manpage-normal.xsl000066400000000000000000000013551331777607200210260ustar00rootroot00000000000000 \ . ndctl-61.2/Documentation/ndctl/000077500000000000000000000000001331777607200165005ustar00rootroot00000000000000ndctl-61.2/Documentation/ndctl/Makefile.am000066400000000000000000000042701331777607200205370ustar00rootroot00000000000000# Copyright(c) 2015-2017 Intel Corporation. # # This program is free software; you can redistribute it and/or modify # it under the terms of version 2 of the GNU General Public License as # published by the Free Software Foundation. # # 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 # General Public License for more details. if USE_ASCIIDOCTOR do_subst = sed -e 's,@Utility@,Ndctl,g' -e's,@utility@,ndctl,g' CONFFILE = asciidoctor-extensions.rb asciidoctor-extensions.rb: ../asciidoctor-extensions.rb.in $(AM_V_GEN) $(do_subst) < $< > $@ else do_subst = sed -e 's,UTILITY,ndctl,g' CONFFILE = asciidoc.conf asciidoc.conf: ../asciidoc.conf.in $(AM_V_GEN) $(do_subst) < $< > $@ endif man1_MANS = \ ndctl.1 \ ndctl-wait-scrub.1 \ ndctl-start-scrub.1 \ ndctl-zero-labels.1 \ ndctl-read-labels.1 \ ndctl-write-labels.1 \ ndctl-init-labels.1 \ ndctl-check-labels.1 \ ndctl-enable-region.1 \ ndctl-disable-region.1 \ ndctl-enable-dimm.1 \ ndctl-disable-dimm.1 \ ndctl-enable-namespace.1 \ ndctl-disable-namespace.1 \ ndctl-create-namespace.1 \ ndctl-destroy-namespace.1 \ ndctl-check-namespace.1 \ ndctl-inject-error.1 \ ndctl-inject-smart.1 \ ndctl-update-firmware.1 \ ndctl-list.1 CLEANFILES = $(man1_MANS) XML_DEPS = \ ../../version.m4 \ Makefile \ $(CONFFILE) \ ../copyright.txt \ region-description.txt \ xable-region-options.txt \ dimm-description.txt \ xable-dimm-options.txt \ xable-namespace-options.txt \ ars-description.txt \ labels-description.txt \ labels-options.txt RM ?= rm -f if USE_ASCIIDOCTOR %.1: %.txt $(XML_DEPS) $(AM_V_GEN)$(RM) $@+ $@ && \ $(ASCIIDOC) -b manpage -d manpage -acompat-mode \ -I. -rasciidoctor-extensions \ -amansource=ndctl -amanmanual="ndctl Manual" \ -andctl_version=$(VERSION) -o $@+ $< && \ mv $@+ $@ else %.xml: %.txt $(XML_DEPS) $(AM_V_GEN)$(RM) $@+ $@ && \ $(ASCIIDOC) -b docbook -d manpage -f asciidoc.conf \ --unsafe -andctl_version=$(VERSION) -o $@+ $< && \ mv $@+ $@ %.1: %.xml $(XML_DEPS) $(AM_V_GEN)$(RM) $@ && \ $(XMLTO) -o . -m ../manpage-normal.xsl man $< endif ndctl-61.2/Documentation/ndctl/ars-description.txt000066400000000000000000000005731331777607200223540ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 DESCRIPTION ----------- NVDIMM Address Range Scrub is a capability provided by platform firmware that allows for the discovery of memory errors by system software. It enables system software to pre-emptively avoid accesses that could lead to uncorrectable memory error handling events, and it otherwise allows memory errors to be enumerated. ndctl-61.2/Documentation/ndctl/dimm-description.txt000066400000000000000000000015141331777607200225110ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 DESCRIPTION ----------- A generic DIMM device object, named /dev/nmemX, is registered for each memory device indicated in the ACPI NFIT table, or other platform NVDIMM resource discovery mechanism. The LIBNVDIMM core provides a built-in driver for these DIMM devices. The driver is responsible for determining if the DIMM implements a namespace label area, and initializing the kernel's in-memory copy of that label data. The kernel performs runtime modifications of that data when namespace provisioning actions are taken, and actively blocks userspace from initiating label data changes while the DIMM is active in any region. Disabling a DIMM, after all the regions it is a member of have been disabled, allows userspace to manually update the label data to be consumed when the DIMM is next enabled. ndctl-61.2/Documentation/ndctl/human-option.txt000066400000000000000000000004031331777607200216540ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 -u:: --human:: Format numbers representing storage sizes, or offsets as human readable strings with units instead of the default machine-friendly raw-integer data. Convert other numeric fields into hexadecimal strings. ndctl-61.2/Documentation/ndctl/labels-description.txt000066400000000000000000000004271331777607200230270ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 DESCRIPTION ----------- The namespace label area is a small persistent partition of capacity available on some NVDIMM devices. The label area is used to resolve aliasing between 'pmem' and 'blk' capacity by delineating namespace boundaries. ndctl-61.2/Documentation/ndctl/labels-options.txt000066400000000000000000000007341331777607200222000ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 :: One or more 'nmemX' device names. The keyword 'all' can be specified to operate on every dimm in the system, optionally filtered by bus id (see --bus= option). -b:: --bus=:: Limit operation to memory devices (dimms) that are on the given bus. Where 'bus' can be a provider name or a bus id number. -v:: Turn on verbose debug messages in the library (if ndctl was built with logging and debug enabled). ndctl-61.2/Documentation/ndctl/namespace-description.txt000066400000000000000000000053411331777607200235210ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 THEORY OF OPERATION ------------------- The capacity of an NVDIMM REGION (contiguous span of persistent memory) is accessed via one or more NAMESPACE devices. REGION is the Linux term for what ACPI and UEFI call a DIMM-interleave-set, or a system-physical-address-range that is striped (by the memory controller) across one or more memory modules. The UEFI specification defines the 'NVDIMM Label Protocol' as the combination of label area access methods and a data format for provisioning one or more NAMESPACE objects from a REGION. Note that label support is optional and if Linux does not detect the label capability it will automatically instantiate a "label-less" namespace per region. Examples of label-less namespaces are the ones created by the kernel's 'memmap=ss!nn' command line option (see the nvdimm wiki on kernel.org), or NVDIMMs without a valid 'namespace index' in their label area. A namespace can be provisioned to operate in one of 4 modes, 'fsdax', 'devdax', 'sector', and 'raw'. Here are the expected usage models for these modes: - fsdax: Filesystem-DAX mode is the default mode of a namespace when specifying 'ndctl create-namespace' with no options. It creates a block device (/dev/pmemX[.Y]) that supports the DAX capabilities of Linux filesystems (xfs and ext4 to date). DAX removes the page cache from the I/O path and allows mmap(2) to establish direct mappings to persistent memory media. The DAX capability enables workloads / working-sets that would exceed the capacity of the page cache to scale up to the capacity of persistent memory. Workloads that fit in page cache or perform bulk data transfers may not see benefit from DAX. When in doubt, pick this mode. - devdax: Device-DAX mode enables similar mmap(2) DAX mapping capabilities as Filesystem-DAX. However, instead of a block-device that can support a DAX-enabled filesystem, this mode emits a single character device file (/dev/daxX.Y). Use this mode to assign persistent memory to a virtual-machine, register persistent memory for RDMA, or when gigantic mappings are needed. - sector: Use this mode to host legacy filesystems that do not checksum metadata or applications that are not prepared for torn sectors after a crash. Expected usage for this mode is for small boot volumes. This mode is compatible with other operating systems. - raw: Raw mode is effectively just a memory disk that does not support DAX. Typically this indicates a namespace that was created by tooling or another operating system that did not know how to create a Linux 'fsdax' or 'devdax' mode namespace. This mode is compatible with other operating systems, but again, does not support DAX operation. ndctl-61.2/Documentation/ndctl/ndctl-check-labels.txt000066400000000000000000000012051331777607200226560ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 ndctl-check-labels(1) ==================== NAME ---- ndctl-check-labels - determine if the given dimms have a valid namespace index block SYNOPSIS -------- [verse] 'ndctl check-labels' [..] [] include::labels-description.txt[] In addition to checking if a label area has a valid index block, running this command in verbose mode reports the reason the index block is deemed invalid. OPTIONS ------- include::labels-options.txt[] include::../copyright.txt[] SEE ALSO -------- http://www.uefi.org/sites/default/files/resources/UEFI_Spec_2_7.pdf[UEFI NVDIMM Label Protocol] ndctl-61.2/Documentation/ndctl/ndctl-check-namespace.txt000066400000000000000000000041011331777607200233460ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 ndctl-check-namespace(1) ========================= NAME ---- ndctl-check-namespace - check namespace metadata consistency SYNOPSIS -------- [verse] 'ndctl check-namespace' [] DESCRIPTION ----------- A namespace in the 'sector' mode will have metadata on it to describe the kernel BTT (Block Translation Table). The check-namespace command can be used to check the consistency of this metadata, and optionally, also attempt to repair it, if it has enough information to do so. The namespace being checked has to be disabled before initiating a check on it as a precautionary measure. The --force option can override this. EXAMPLES -------- Check a namespace (only report errors) [verse] ndctl disable-namespace namespace0.0 ndctl check-namespace namespace0.0 Check a namespace, and perform repairs if possible [verse] ndctl disable-namespace namespace0.0 ndctl check-namespace --repair namespace0.0 OPTIONS ------- -R:: --repair:: Perform metadata repairs if possible. Without this option, the raw namespace contents will not be touched. -L:: --rewrite-log:: Regenerate the BTT log and write it to media. This can be used to convert from the old (pre 4.15) padding format that was incompatible with other BTT implementations to the updated format. This requires the --repair option to be provided. WARNING: Do not interrupt this operation as it can potentially cause unrecoverable metadata corruption. It is highly recommended to create a backup of the raw namespace before attempting this. -f:: --force:: Unless this option is specified, a check-namespace operation will fail if the namespace is presently active. Specifying --force causes the namespace to be disabled before checking. -v:: --verbose:: Emit debug messages for the namespace check process. -r:: --region=:: include::xable-region-options.txt[] include::../copyright.txt[] SEE ALSO -------- linkndctl:ndctl-disable-namespace[1], linkndctl:ndctl-enable-namespace[1], http://www.uefi.org/sites/default/files/resources/UEFI_Spec_2_7.pdf[UEFI NVDIMM Label Protocol] ndctl-61.2/Documentation/ndctl/ndctl-create-namespace.txt000066400000000000000000000203221331777607200235370ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 ndctl-create-namespace(1) ========================= NAME ---- ndctl-create-namespace - provision or reconfigure a namespace SYNOPSIS -------- [verse] 'ndctl create-namespace' [] include::namespace-description.txt[] EXAMPLES -------- Create a maximally sized pmem namespace in 'fsdax' mode (the default) [verse] ndctl create-namespace Convert namespace0.0 to 'sector' mode [verse] ndctl create-namespace -f -e namespace0.0 --mode=sector OPTIONS ------- -t:: --type=:: Create a 'pmem' or 'blk' namespace (subject to available capacity). A pmem namespace supports the dax (direct access) capability to linkndctl:mmap[2] persistent memory directly into a process address space. A blk namespace access persistent memory through a block-window-aperture. Compared to pmem it supports a traditional storage error model (EIO on error rather than a cpu exception on a bad memory access), but it does not support dax. -m:: --mode=:: - "raw": expose the namespace capacity directly with limitations. Neither a raw pmem namepace nor raw blk namespace support sector atomicity by default (see "sector" mode below). A raw pmem namespace may have limited to no dax support depending the kernel. In other words operations like direct-I/O targeting a dax buffer may fail for a pmem namespace in raw mode or indirect through a page-cache buffer. See "fsdax" and "devdax" mode for dax operation. - "sector": persistent memory, given that it is byte addressable, does not support sector atomicity. The problematic aspect of sector tearing is that most applications do not know they have a atomic sector update dependency. At least a disk rarely ever tears sectors and if it does it almost certainly returns a checksum error on access. Persistent memory devices will always tear and always silently. Until an application is audited to be robust in the presence of sector-tearing "safe" mode is recommended. This imposes some performance overhead and disables the dax capability. (also known as "safe" or "btt" mode) - "fsdax": A pmem namespace in this mode supports dax operation with a block-device based filesystem (in previous ndctl releases this mode was named "memory" mode). This mode comes at the cost of allocating per-page metadata. The capacity can be allocated from "System RAM", or from a reserved portion of "Persistent Memory" (see the --map= option). Note that a filesystem is required for dax operation, the resulting raw block device (/dev/pmemX) will use the page cache. See "devdax" mode for raw device access that supports dax. - "devdax": The device-dax character device interface is a statically allocated / raw access analogue of filesystem-dax (in previous ndctl releases this mode was named "dax" mode). It allows memory ranges to be mapped without need of an intervening filesystem. The device-dax is interface strict, precise and predictable. Specifically the interface: * Guarantees fault granularity with respect to a given page size (4K, 2M, or 1G on x86) set at configuration time. * Enforces deterministic behavior by being strict about what fault scenarios are supported. I.e. if a device is configured with a 2M alignment an attempt to fault a 4K aligned offset will result in SIGBUS. -s:: --size=:: For NVDIMM devices that support namespace labels, set the namespace size in bytes. Otherwise it defaults to the maximum size specified by platform firmware. This option supports the suffixes "k" or "K" for KiB, "m" or "M" for MiB, "g" or "G" for GiB and "t" or "T" for TiB. For pmem namepsaces the size must be a multiple of the interleave-width and the namespace alignment (see below). -a:: --align:: Applications that want to establish dax memory mappings with page table entries greater than system base page size (4K on x86) need a persistent memory namespace that is sufficiently aligned. For "fsdax" and "devdax" mode this defaults to 2M. Note that "devdax" mode enforces all mappings to be aligned to this value, i.e. it fails unaligned mapping attempts. The "fsdax" alignment setting determines the starting alignment of filesystem extents and may limit the possible granularities, if a large mapping is not possible it will silently fall back to a smaller page size. -e:: --reconfig=:: Reconfigure an existing namespace (change the mode, sector size, etc...). All namespace parameters, save uuid, default to the current attributes of the specified namespace. The namespace is then re-created with the specified modifications. The uuid is refreshed to a new value by default whenever the data layout of a namespace is changed, see --uuid= to set a specific uuid. -u:: --uuid=:: This option is not recommended as a new uuid should be generated every time a namespace is (re-)created. For recovery scenarios however the uuid may be specified. -n:: --name=:: For NVDIMM devices that support namespace labels, specify a human friendly name for a namespace. This name is available as a device attribute for use in udev rules. -l:: --sector-size:: Specify the logical sector size (LBA size) of the Linux block device associated with an namespace. -M:: --map=:: A pmem namespace in "fsdax" or "devdax" mode requires allocation of per-page metadata. The allocation can be drawn from either: - "mem": typical system memory - "dev": persistent memory reserved from the namespace Given relative capacities of "Persistent Memory" to "System RAM" the allocation defaults to reserving space out of the namespace directly ("--map=dev"). The overhead is 64-bytes per 4K (16GB per 1TB) on x86. -f:: --force:: Unless this option is specified the 'reconfigure namespace' operation will fail if the namespace is presently active. Specifying --force causes the namespace to be disabled before the operation is attempted. However, if the namespace is mounted then the 'disable namespace' and 'reconfigure namespace' operations will be aborted. The namespace must be unmounted before being reconfigured. -L:: --autolabel:: --no-autolabel:: Legacy NVDIMM devices do not support namespace labels. In that case the kernel creates region-sized namespaces that can not be deleted. Their mode can be changed, but they can not be resized smaller than their parent region. This is termed a "label-less namespace". In contrast, NVDIMMs and hypervisors that support the ACPI 6.2 label area definition (ACPI 6.2 Section 6.5.10 NVDIMM Label Methods) support "labelled namespace" operation. - There are two cases where the kernel will default to label-less operation: * NVDIMM does not support labels * The NVDIMM supports labels, but the Label Index Block (see UEFI 2.7) is not present and there is no capacity aliasing between 'blk' and 'pmem' regions. - In the latter case the configuration can be upgraded to labelled operation by writing an index block on all DIMMs in a region and re-enabling that region. The 'autolabel' capability of 'ndctl create-namespace --reconfig' tries to do this by default if it can determine that all DIMM capacity is referenced by the namespace being reconfigured. It will otherwise fail to autolabel and remain in label-less mode if it finds a DIMM contributes capacity to more than one region. This check prevents inadvertent data loss of that other region is in active use. The --autolabel option is implied by default, the --no-autolabel option can be used to disable this behavior. When automatic labeling fails and labelled operation is still desired the safety policy can be bypassed by the following commands, note that all data on all regions is forfeited by running these commands: ndctl disable-region all ndctl init-labels all ndctl enable-region all -v:: --verbose:: Emit debug messages for the namespace creation process -r:: --region=:: include::xable-region-options.txt[] include::../copyright.txt[] SEE ALSO -------- linkndctl:ndctl-zero-labels[1], linkndctl:ndctl-init-labels[1], linkndctl:ndctl-disable-namespace[1], linkndctl:ndctl-enable-namespace[1], http://www.uefi.org/sites/default/files/resources/UEFI_Spec_2_7.pdf[UEFI NVDIMM Label Protocol] https://nvdimm.wiki.kernel.org[Linux Persistent Memory Wiki] ndctl-61.2/Documentation/ndctl/ndctl-destroy-namespace.txt000066400000000000000000000014561331777607200237740ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 ndctl-destroy-namespace(1) ========================= NAME ---- ndctl-destroy-namespace - destroy the given namespace(s) SYNOPSIS -------- [verse] 'ndctl destroy-namespace' [] include::namespace-description.txt[] OPTIONS ------- include::xable-namespace-options.txt[] -f:: --force:: Unless this option is specified the 'destroy namespace' operation will fail if the namespace is presently active. Specifying --force causes the namespace to be disabled before the operation is attempted. However, if the namespace is mounted then the 'disable namespace' and 'destroy namespace' operations will be aborted. The namespace must be unmounted before being destroyed. include::../copyright.txt[] SEE ALSO -------- linkndctl:ndctl-create-namespace[1] ndctl-61.2/Documentation/ndctl/ndctl-disable-dimm.txt000066400000000000000000000005771331777607200227030ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 ndctl-disable-dimm(1) ===================== NAME ---- ndctl-disable-dimm - disable one or more idle dimms SYNOPSIS -------- [verse] 'ndctl disable-dimm' [] include::dimm-description.txt[] OPTIONS ------- :: include::xable-dimm-options.txt[] include::../copyright.txt[] SEE ALSO -------- linkndctl:ndctl-enable-dimm[1] ndctl-61.2/Documentation/ndctl/ndctl-disable-namespace.txt000066400000000000000000000006361331777607200237050ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 ndctl-disable-namespace(1) ========================= NAME ---- ndctl-disable-namespace - disable the given namespace(s) SYNOPSIS -------- [verse] 'ndctl disable-namespace' [] include::namespace-description.txt[] OPTIONS ------- include::xable-namespace-options.txt[] include::../copyright.txt[] SEE ALSO -------- linkndctl:ndctl-disable-namespace[1] ndctl-61.2/Documentation/ndctl/ndctl-disable-region.txt000066400000000000000000000006541331777607200232340ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 ndctl-disable-region(1) ======================= NAME ---- ndctl-disable-region - disable the given region(s) and all descendant namespaces SYNOPSIS -------- [verse] 'ndctl disable-region' [] include::region-description.txt[] OPTIONS ------- :: include::xable-region-options.txt[] include::../copyright.txt[] SEE ALSO -------- linkndctl:ndctl-enable-region[1] ndctl-61.2/Documentation/ndctl/ndctl-enable-dimm.txt000066400000000000000000000005631331777607200225210ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 ndctl-enable-dimm(1) ==================== NAME ---- ndctl-enable-dimm - enable one more dimms SYNOPSIS -------- [verse] 'ndctl enable-dimm' [] include::dimm-description.txt[] OPTIONS ------- :: include::xable-dimm-options.txt[] include::../copyright.txt[] SEE ALSO -------- linkndctl:ndctl-disable-dimm[1] ndctl-61.2/Documentation/ndctl/ndctl-enable-namespace.txt000066400000000000000000000006321331777607200235240ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 ndctl-enable-namespace(1) ========================= NAME ---- ndctl-enable-namespace - enable the given namespace(s) SYNOPSIS -------- [verse] 'ndctl enable-namespace' [] include::namespace-description.txt[] OPTIONS ------- include::xable-namespace-options.txt[] include::../copyright.txt[] SEE ALSO -------- linkndctl:ndctl-disable-namespace[1] ndctl-61.2/Documentation/ndctl/ndctl-enable-region.txt000066400000000000000000000006501331777607200230530ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 ndctl-enable-region(1) ====================== NAME ---- ndctl-enable-region - enable the given region(s) and all descendant namespaces SYNOPSIS -------- [verse] 'ndctl enable-region' [] include::region-description.txt[] OPTIONS ------- :: include::xable-region-options.txt[] include::../copyright.txt[] SEE ALSO -------- linkndctl:ndctl-disable-region[1] ndctl-61.2/Documentation/ndctl/ndctl-init-labels.txt000066400000000000000000000036411331777607200225520ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 ndctl-init-labels(1) ==================== NAME ---- ndctl-init-labels - initialize the label data area on a dimm or set of dimms SYNOPSIS -------- [verse] 'ndctl init-labels' [..] [] include::labels-description.txt[] By default, and in kernels prior to v4.10, the kernel only honors labels when a DIMM aliases PMEM and BLK capacity. Starting with v4.10 the kernel will honor labels for sub-dividing PMEM if all the DIMMs in an interleave set / region have a valid namespace index block. This command can be used to initialize the namespace index block if it is missing or reinitialize it if it is damaged. Note that reinitialization effectively destroys all existing namespace labels on the DIMM. EXAMPLE ------- Find the DIMMs that comprise a given region: ---- # ndctl list -RD --region=region1 { "dimms":[ { "dev":"nmem0", "id":"8680-56341200" } ], "regions":[ { "dev":"region1", "size":268435456, "available_size":0, "type":"pmem", "mappings":[ { "dimm":"nmem0", "offset":13958643712, "length":268435456 } ] } ] } ---- Disable that region so the DIMM label area can be written from userspace: ---- # ndctl disable-region region1 ---- Initialize labels: ---- # ndctl init-labels nmem0 ---- Re-enable the region: ---- # ndctl enable-region region1 ---- Create a namespace in that region: ---- # ndctl create-namespace --region=region1 ---- OPTIONS ------- include::labels-options.txt[] -f:: --force:: Force initialization of the label space even if there appears to be an existing / valid namespace index. Warning, this will destroy all defined namespaces on the dimm. include::../copyright.txt[] SEE ALSO -------- linkndctl:ndctl-create-namespace[1], http://www.uefi.org/sites/default/files/resources/UEFI_Spec_2_7.pdf[UEFI NVDIMM Label Protocol] ndctl-61.2/Documentation/ndctl/ndctl-inject-error.txt000066400000000000000000000076601331777607200227570ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 ndctl-inject-error(1) ===================== NAME ---- ndctl-inject-error - inject media errors at a namespace offset SYNOPSIS -------- [verse] 'ndctl inject-error' [] include::namespace-description.txt[] ndctl-inject-error can be used to ask the platform to simulate media errors in the NVDIMM address space to aid debugging and development of features related to error handling. By default, injecting an error actually only injects an error to the first 'n' bytes of the block, where 'n' is the output of ndctl_cmd_ars_cap_get_size(). In other words, we only inject one 'ars_unit' per sector. This is sufficient for Linux to mark the whole sector as bad, and will show up as such in the various 'badblocks' lists in the kernel. If multiple blocks are being injected, only the first 'n' bytes of each block specified will be injected as errors. This can be overridden by the --saturate option, which will force the entire block to be injected as an error. WARNING: These commands are DANGEROUS and can cause data loss. They are only provided for testing and debugging purposes. EXAMPLES -------- Inject errors in namespace0.0 at block 12 for 2 blocks (i.e. 12, 13) [verse] ndctl inject-error --block=12 --count=2 namespace0.0 Check status of injected errors on namespace0.0 [verse] ndctl inject-error --status namespace0.0 Uninject errors at block 12 for 2 blocks on namespace0.0 [verse] ndctl inject-error --uninject --block=12 --count=2 namespace0.0 OPTIONS ------- -B:: --block=:: Namespace block offset in 512 byte sized blocks where the error is to be injected. NOTE: The offset is interpreted in different ways based on the "mode" of the namespace. For "raw" mode, the offset is the base namespace offset. For "fsdax" mode (i.e. a "pfn" namespace), the offset is relative to the user-visible part of the namespace, and the offset introduced by the kernel's metadata will be accounted for. For a "sector" mode namespace (i.e. a "BTT" namespace), the offset is relative to the base namespace, as the BTT translation details are internal to the kernel, and can't be accounted for while injecting errors. -n:: --count=:: Number of blocks to inject as errors. This is also in terms of fixed, 512 byte blocks. -d:: --uninject:: This option will ask the platform to remove any injected errors for the specified block offset, and count. WARNING: This will not clear the kernel's internal badblock tracking, those can only be cleared by doing a write to the affected locations. Hence use the --clear option only if you know exactly what you are doing. For normal usage, injected errors should only be cleared by doing writes. Do not expect have the original data intact after injecting an error, and clearing it using --clear - it will be lost, as the only "real" way to clear the error location is to write to it or zero it (truncate/hole-punch). -t:: --status:: This option will retrieve the status of injected errors. Note that this will not retrieve all known/latent errors (i.e. non injected ones), and is NOT equivalent to performing an Address Range Scrub. -N:: --no-notify:: This option is only valid when injecting errors. By default, the error inject command and will ask platform firmware to trigger a notification in the kernel, asking it to update its state of known errors. With this option, the error will still be injected, the kernel will not get a notification, and the error will appear as a latent media error when the location is accessed. If the platform firmware does not support this feature, this will have no effect. -S:: --saturate:: This option forces error injection or un-injection to cover the entire address range covered by the specified block(s). -v:: --verbose:: Emit debug messages for the error injection process include::human-option.txt[] -r:: --region=:: include::xable-region-options.txt[] include::../copyright.txt[] SEE ALSO -------- linkndctl:ndctl-list[1], ndctl-61.2/Documentation/ndctl/ndctl-inject-smart.txt000066400000000000000000000044171331777607200227510ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 ndctl-inject-smart(1) ===================== NAME ---- ndctl-inject-smart - perform smart threshold/injection operations on a DIMM SYNOPSIS -------- [verse] 'ndctl inject-smart' [] DESCRIPTION ----------- A generic DIMM device object, named /dev/nmemX, is registered for each memory device indicated in the ACPI NFIT table, or other platform NVDIMM resource discovery mechanism. ndctl-inject-smart can be used to set smart thresholds, and inject smart attributes. EXAMPLES -------- Set smart controller temperature and spares threshold for DIMM-0 to 32C, spares threshold to 8, and enable the spares alarm. [verse] ndctl inject-smart --ctrl-temperature-threshold=32 --spares-threshold=8 --spares-alarm nmem0 Inject a media temperature value of 52 and fatal health status flag for DIMM-0 [verse] ndctl inject-smart --media-temperature=52 --health=fatal nmem0 OPTIONS ------- -b:: --bus=:: Enforce that the operation only be carried on devices that are attached to the given bus. Where 'bus' can be a provider name or a bus id number. -m:: --media-temperature=:: Inject for the media temperature smart attribute. -M:: --media-temperature-threshold=:: Set for the smart media temperature threshold. --media-temperature-alarm=:: Enable or disable the smart media temperature alarm. Options are 'on' or 'off'. -c:: --ctrl-temperature=:: Inject for the controller temperature smart attribute. -C:: --ctrl-temperature-threshold=:: Set for the smart controller temperature threshold. --ctrl-temperature-alarm=:: Enable or disable the smart controller temperature alarm. Options are 'on' or 'off'. -s:: --spares=:: Inject for the spares smart attribute. -S:: --spares-threshold=:: Set for the smart spares threshold. --spares-alarm=:: Enable or disable the smart spares alarm. Options are 'on' or 'off'. -H:: --health=:: Smart attribute for health status. Provide either 'fatal' or 'nominal' to set the state of the attribute. -U:: --unsafe-shutdown=:: Set the flag to spoof an unsafe shutdown on the next power down. -v:: --verbose:: Emit debug messages for the error injection process include::human-option.txt[] include::../copyright.txt[] SEE ALSO -------- linkndctl:ndctl-list[1], ndctl-61.2/Documentation/ndctl/ndctl-list.txt000066400000000000000000000104231331777607200213160ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 ndctl-list(1) ============= NAME ---- ndctl-list - dump the platform nvdimm device topology and attributes in json SYNOPSIS -------- [verse] 'ndctl list' [] Walk all the nvdimm buses in the system and list all attached devices along with some of their major attributes. Options can be specified to limit the output to devices of a certain class. Where the classes are buses, dimms, regions, and namespaces. By default, 'ndctl list' with no options is equivalent to: [verse] ndctl list --namespaces --bus=all --region=all EXAMPLE ------- ---- # ndctl list --buses --namespaces { "provider":"nfit_test.1", "dev":"ndbus2", "namespaces":[ { "dev":"namespace9.0", "mode":"raw", "size":33554432, "blockdev":"pmem9" } ] } { "provider":"nfit_test.0", "dev":"ndbus1" } { "provider":"e820", "dev":"ndbus0", "namespaces":[ { "dev":"namespace0.0", "mode":"fsdax", "size":8589934592, "blockdev":"pmem0" } ] } ---- OPTIONS ------- -r:: --region=:: include::xable-region-options.txt[] -d:: --dimm=:: An 'nmemX' device name, or dimm id number. Filter listing by devices that reference the given dimm. For example to see all namespaces comprised of storage capacity on nmem0: ---- # ndctl list --dimm=nmem0 --namespaces ---- -n:: --namespace=:: An 'namespaceX.Y' device name, or namespace region plus id tuple 'X.Y'. Limit the namespace list to the single identified device if present. -t:: --type=:: Filter listing by region type ('pmem' or 'blk') -m:: --mode=:: Filter listing by the mode ('raw', 'fsdax', 'sector' or 'devdax') of the namespace(s). -U:: --numa-node=:: Filter listing by numa node -B:: --buses:: Include bus info in the listing -D:: --dimms:: Include dimm info in the listing -H:: --health:: Include dimm health info in the listing. For example: [verse] { "dev":"nmem0", "health":{ "health_state":"non-critical", "temperature_celsius":23, "spares_percentage":75, "alarm_temperature":true, "alarm_spares":true, "temperature_threshold":40, "spares_threshold":5, "life_used_percentage":5, "shutdown_state":"clean" } } -F:: --firmware:: Include dimm firmware info in the listing. For example: [verse] { "dev":"nmem0", "firmware":{ "current_version":0, "next_version":1, "need_powercycle":true } } -X:: --device-dax:: Include device-dax ("daxregion") details when a namespace is in "devdax" mode. [verse] { "dev":"namespace0.0", "mode":"devdax", "size":4225761280, "uuid":"18ae1bbb-bb62-4efc-86df-4a5caacb5dcc", "daxregion":{ "id":0, "size":4225761280, "align":2097152, "devices":[ { "chardev":"dax0.0", "size":4225761280 } ] } } -R:: --regions:: Include region info in the listing -N:: --namespaces:: Include namespace info in the listing. Namespace info is listed by default if no other options are specified to the command. -i:: --idle:: Include idle (not enabled) devices in the listing -M:: --media-errors:: Include media errors (badblocks) in the listing. Note that the 'badblock_count' property is included in the listing by default when the count is non-zero, otherwise it is hidden. Also, if the namespace is in 'sector' mode the 'badblocks' listing is not included and 'badblock_count' property may include blocks that are located in metadata, or unused capacity in the namespace. Convert a 'sector' namespace into 'raw' mode to list precise 'badblocks' offsets. [verse] { "dev":"namespace7.0", "mode":"raw", "size":33554432, "blockdev":"pmem7", "badblock_count":17, "badblocks":[ { "offset":4, "length":1 }, { "offset":32768, "length":8 }, { "offset":65528, "length":8 } ] } include::human-option.txt[] ---- # ndctl list --region=7 { "dev":"region7", "size":67108864, "available_size":67108864, "type":"pmem", "iset_id":-6382611090938810793, "badblock_count":8 } ---- ---- # ndctl list --human --region=7 { "dev":"region7", "size":"64.00 MiB (67.11 MB)", "available_size":"64.00 MiB (67.11 MB)", "type":"pmem", "iset_id":"0xa76c6907811fae57", "badblock_count":8 } ---- include::../copyright.txt[] SEE ALSO -------- linkndctl:ndctl-create-namespace[1] ndctl-61.2/Documentation/ndctl/ndctl-read-labels.txt000066400000000000000000000013371331777607200225220ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 ndctl-read-labels(1) ==================== NAME ---- ndctl-read-labels - read out the label area on a dimm or set of dimms SYNOPSIS -------- [verse] 'ndctl read-labels' [..] [] include::labels-description.txt[] This command dumps the raw binary data in a dimm's label area to stdout or a file. In the multi-dimm case the data is concatenated. OPTIONS ------- include::labels-options.txt[] -o:: --output:: output file -j:: --json:: parse the label data into json assuming the 'NVDIMM Namespace Specification' format. include::../copyright.txt[] SEE ALSO -------- http://www.uefi.org/sites/default/files/resources/UEFI_Spec_2_7.pdf[UEFI NVDIMM Label Protocol] ndctl-61.2/Documentation/ndctl/ndctl-start-scrub.txt000066400000000000000000000026531331777607200226220ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 ndctl-start-scrub(1) ==================== NAME ---- ndctl-start-scrub - start an Address Range Scrub (ARS) operation SYNOPSIS -------- [verse] 'ndctl start-scrub' [

... ] [] include::ars-description.txt[] The kernel provides a sysfs file ('scrub') that when written with the string "1\n" initiates an ARS operation. The 'ndctl start-scrub' operation starts an ARS, across all specified buses, and the kernel in turn proceeds to scrub every persistent memory address region on the specified buses. EXAMPLE ------- Start a scrub on all nvdimm buses in the system. The json listing report only includes the buses that support ARS operations. ---- # ndctl start-scrub [ { "provider":"nfit_test.1", "dev":"ndbus3", "scrub_state":"active" }, { "provider":"nfit_test.0", "dev":"ndbus2", "scrub_state":"active" } ] ---- When specifying an individual bus, or if there is only one bus in the system, the command reports whether ARS support is available. ---- # ndctl start-scrub e820 error starting scrub: Operation not supported ---- OPTIONS ------- -v:: --verbose:: Emit debug messages for the ARS start process include::../copyright.txt[] SEE ALSO -------- linkndctl:ndctl-wait-scrub[1], http://www.uefi.org/sites/default/files/resources/ACPI%206_2_A_Sept29.pdf[ACPI 6.2 Specification Section 9.20.7.2 Address Range Scrubbing (ARS) Overview] ndctl-61.2/Documentation/ndctl/ndctl-update-firmware.txt000066400000000000000000000012221331777607200234340ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 ndctl-update-firmware(1) ======================== NAME ---- ndctl-update-firmware - provides for updating the firmware on an NVDIMM SYNOPSIS -------- [verse] 'ndctl update-firmware' [] DESCRIPTION ----------- Provide a generic interface for updating NVDIMM firmware. The use of this depends on support from the underlying libndctl, kernel, as well as the platform itself. OPTIONS ------- :: include::xable-dimm-options.txt[] -f:: --firmware:: firmware file used to perform the update -v:: --verbose:: Emit debug messages for the namespace check process. include::../copyright.txt[] ndctl-61.2/Documentation/ndctl/ndctl-wait-scrub.txt000066400000000000000000000030441331777607200224240ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 ndctl-wait-scrub(1) ==================== NAME ---- ndctl-wait-scrub - wait for an Address Range Scrub (ARS) operation to complete SYNOPSIS -------- [verse] 'ndctl wait-scrub' [

... ] [] include::ars-description.txt[] The kernel provides a POLL(2) capable sysfs file ('scrub') to indicate the state of ARS. The 'scrub' file maintains a running count of ARS runs that have taken place. While a current run is in progress a '+' character is emitted along with the current count. The 'ndctl wait-scrub' operation waits for 'scrub', across all specified buses, to indicate not in-progress at least once. EXAMPLE ------- Wait for scrub on all nvdimm buses in the system. The json listing report at the end only includes the buses that support ARS operations. ---- # ndctl wait-scrub [ { "provider":"nfit_test.1", "dev":"ndbus3", "scrub_state":"idle" }, { "provider":"nfit_test.0", "dev":"ndbus2", "scrub_state":"idle" } ] ---- When specifying an individual bus, or if there is only one bus in the system, the command reports whether ARS support is available. ---- # ndctl wait-scrub e820 error waiting for scrub completion: Operation not supported ---- OPTIONS ------- -v:: --verbose:: Emit debug messages for the ARS wait process include::../copyright.txt[] SEE ALSO -------- linkndctl:ndctl-start-scrub[1], http://www.uefi.org/sites/default/files/resources/ACPI%206_2_A_Sept29.pdf[ACPI 6.2 Specification Section 9.20.7.2 Address Range Scrubbing (ARS) Overview] ndctl-61.2/Documentation/ndctl/ndctl-write-labels.txt000066400000000000000000000012361331777607200227370ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 ndctl-write-labels(1) ===================== NAME ---- ndctl-write-labels - write data to the label area on a dimm SYNOPSIS -------- [verse] 'ndctl write-labels [-i ]' include::labels-description.txt[] Read data from the input filename, or stdin, and write it to the given device. Note that the device must not be active in any region, otherwise the kernel will not allow write access to the device's label data area. OPTIONS ------- include::labels-options.txt[] -i:: --input:: input file SEE ALSO -------- http://www.uefi.org/sites/default/files/resources/UEFI_Spec_2_7.pdf[UEFI NVDIMM Label Protocol] ndctl-61.2/Documentation/ndctl/ndctl-zero-labels.txt000066400000000000000000000010441331777607200225610ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 ndctl-zero-labels(1) ==================== NAME ---- ndctl-zero-labels - zero out the label area on a dimm or set of dimms SYNOPSIS -------- [verse] 'ndctl zero-labels' [..] [] include::labels-description.txt[] This command resets the device to its default state by deleting all labels. OPTIONS ------- include::labels-options.txt[] include::../copyright.txt[] SEE ALSO -------- http://www.uefi.org/sites/default/files/resources/UEFI_Spec_2_7.pdf[UEFI NVDIMM Label Protocol] ndctl-61.2/Documentation/ndctl/ndctl.txt000066400000000000000000000026421331777607200203510ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 ndctl(1) ======= NAME ---- ndctl - Manage "libnvdimm" subsystem devices (Non-volatile Memory) SYNOPSIS -------- [verse] 'ndctl' [--version] [--help] [OPTIONS] COMMAND [ARGS] OPTIONS ------- -v:: --version:: Display ndctl version. -h:: --help:: Run ndctl help command. DESCRIPTION ----------- ndctl is utility for managing the "libnvdimm" kernel subsystem. The "libnvdimm" subsystem defines a kernel device model and control message interface for platform NVDIMM resources like those defined by the ACPI 6.0 NFIT (NVDIMM Firmware Interface Table). Operations supported by the tool include, provisioning capacity (namespaces), as well as enumerating/enabling/disabling the devices (dimms, regions, namspaces) associated with an NVDIMM bus. include::../copyright.txt[] SEE ALSO -------- linkndctl:ndctl-create-namespace[1], linkndctl:ndctl-destroy-namespace[1], linkndctl:ndctl-check-namespace[1], linkndctl:ndctl-enable-region[1], linkndctl:ndctl-disable-region[1], linkndctl:ndctl-enable-dimm[1], linkndctl:ndctl-disable-dimm[1], linkndctl:ndctl-enable-namespace[1], linkndctl:ndctl-disable-namespace[1], linkndctl:ndctl-zero-labels[1], linkndctl:ndctl-read-labels[1], linkndctl:ndctl-inject-error[1], linkndctl:ndctl-list[1], https://www.kernel.org/doc/Documentation/nvdimm/nvdimm.txt[LIBNVDIMM Overview], http://pmem.io/documents/NVDIMM_Driver_Writers_Guide.pdf[NVDIMM Driver Writer's Guide] ndctl-61.2/Documentation/ndctl/region-description.txt000066400000000000000000000007071331777607200230510ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 DESCRIPTION ----------- A generic REGION device is registered for each PMEM range or BLK-aperture set. LIBNVDIMM provides a built-in driver for these REGION devices. This driver is responsible for reconciling the aliased DPA mappings across all regions, parsing the LABEL, if present, and then emitting NAMESPACE devices with the resolved/exclusive DPA-boundaries for the nd_pmem or nd_blk device driver to consume. ndctl-61.2/Documentation/ndctl/xable-dimm-options.txt000066400000000000000000000006051331777607200227520ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 A 'nmemX' device name, or a dimm id number. The keyword 'all' can be specified to carry out the operation on every dimm in the system, optionally filtered by bus id (see --bus= option). -b:: --bus=:: Enforce that the operation only be carried on devices that are attached to the given bus. Where 'bus' can be a provider name or a bus id number. ndctl-61.2/Documentation/ndctl/xable-namespace-options.txt000066400000000000000000000005361331777607200237630ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 :: A 'namespaceX.Y' device name. The keyword 'all' can be specified to carry out the operation on every namespace in the system, optionally filtered by region (see --region=option) -r:: --region=:: include::xable-region-options.txt[] -v:: --verbose:: Emit debug messages for the namespace operation ndctl-61.2/Documentation/ndctl/xable-region-options.txt000066400000000000000000000006131331777607200233060ustar00rootroot00000000000000// SPDX-License-Identifier: GPL-2.0 A 'regionX' device name, or a region id number. The keyword 'all' can be specified to carry out the operation on every region in the system, optionally filtered by bus id (see --bus= option). -b:: --bus=:: Enforce that the operation only be carried on devices that are attached to the given bus. Where 'bus' can be a provider name or a bus id number. ndctl-61.2/Makefile.am000066400000000000000000000040051331777607200146160ustar00rootroot00000000000000include Makefile.am.in ACLOCAL_AMFLAGS = -I m4 ${ACLOCAL_FLAGS} SUBDIRS = . daxctl/lib ndctl/lib ndctl daxctl if ENABLE_DOCS SUBDIRS += Documentation/ndctl Documentation/daxctl endif SUBDIRS += test BUILT_SOURCES = version.m4 version.m4: FORCE $(AM_V_GEN)$(top_srcdir)/git-version-gen FORCE: noinst_SCRIPTS = rhel/ndctl.spec sles/ndctl.spec CLEANFILES += $(noinst_SCRIPTS) do_rhel_subst = sed -e 's,VERSION,$(VERSION),g' \ -e 's,DAX_DNAME,daxctl-devel,g' \ -e 's,DNAME,ndctl-devel,g' \ -e '/^%defattr.*/d' \ -e 's,DAX_LNAME,daxctl-libs,g' \ -e 's,LNAME,ndctl-libs,g' do_sles_subst = sed -e 's,VERSION,$(VERSION),g' \ -e 's,DAX_DNAME,libdaxctl-devel,g' \ -e 's,DNAME,libndctl-devel,g' \ -e 's,%license,%doc,g' \ -e 's,$^License:.*GPL$v2,\1-2.0,g' \ -e "s,DAX_LNAME,libdaxctl$$(($(LIBDAXCTL_CURRENT) - $(LIBDAXCTL_AGE))),g" \ -e "s,LNAME,libndctl$$(($(LIBNDCTL_CURRENT) - $(LIBNDCTL_AGE))),g" rhel/ndctl.spec: ndctl.spec.in Makefile.am version.m4 $(AM_V_GEN)$(MKDIR_P) rhel; $(do_rhel_subst) < $< > $@ sles/ndctl.spec: ndctl.spec.in Makefile.am version.m4 $(AM_V_GEN)$(MKDIR_P) sles; cat sles/header $< | $(do_sles_subst) > $@ if ENABLE_BASH_COMPLETION bashcompletiondir = $(BASH_COMPLETION_DIR) dist_bashcompletion_DATA = contrib/ndctl endif noinst_LIBRARIES = libccan.a libccan_a_SOURCES = \ ccan/str/str.h \ ccan/str/str_debug.h \ ccan/str/str.c \ ccan/str/debug.c \ ccan/list/list.h \ ccan/list/list.c \ ccan/container_of/container_of.h \ ccan/check_type/check_type.h \ ccan/build_assert/build_assert.h \ ccan/array_size/array_size.h \ ccan/minmax/minmax.h \ ccan/short_types/short_types.h \ ccan/endian/endian.h noinst_LIBRARIES += libutil.a libutil_a_SOURCES = \ util/parse-options.c \ util/parse-options.h \ util/usage.c \ util/size.c \ util/main.c \ util/help.c \ util/strbuf.c \ util/wrapper.c \ util/filter.c \ util/bitmap.c \ util/abspath.c nobase_include_HEADERS = daxctl/libdaxctl.h ndctl-61.2/Makefile.am.in000066400000000000000000000016271331777607200152320ustar00rootroot00000000000000EXTRA_DIST = CLEANFILES = AM_MAKEFLAGS = --no-print-directory AM_CPPFLAGS = \ -include $(top_builddir)/config.h \ -DSYSCONFDIR=\""$(sysconfdir)"\" \ -DLIBEXECDIR=\""$(libexecdir)"\" \ -DPREFIX=\""$(prefix)"\" \ -DNDCTL_MAN_PATH=\""$(mandir)"\" \ -I${top_srcdir}/ndctl/lib \ -I${top_srcdir}/ndctl \ -I${top_srcdir}/ \ $(KMOD_CFLAGS) \ $(UDEV_CFLAGS) \ $(UUID_CFLAGS) \ $(JSON_CFLAGS) AM_CFLAGS = ${my_CFLAGS} \ -fvisibility=hidden \ -ffunction-sections \ -fdata-sections AM_LDFLAGS = \ -Wl,--gc-sections \ -Wl,--as-needed SED_PROCESS = \ $(AM_V_GEN)$(MKDIR_P) $(dir $@) && $(SED) \ -e 's,@VERSION\@,$(VERSION),g' \ -e 's,@prefix\@,$(prefix),g' \ -e 's,@exec_prefix\@,$(exec_prefix),g' \ -e 's,@libdir\@,$(libdir),g' \ -e 's,@includedir\@,$(includedir),g' \ < $< > $@ || rm $@ LIBNDCTL_CURRENT=16 LIBNDCTL_REVISION=1 LIBNDCTL_AGE=10 LIBDAXCTL_CURRENT=3 LIBDAXCTL_REVISION=0 LIBDAXCTL_AGE=2 ndctl-61.2/README.md000066400000000000000000000071001331777607200140400ustar00rootroot00000000000000# ndctl Utility library for managing the libnvdimm (non-volatile memory device) sub-system in the Linux kernel Build ===== ``` ./autogen.sh ./configure CFLAGS='-g -O2' --prefix=/usr --sysconfdir=/etc --libdir=/usr/lib64 make make check sudo make install ``` There are a number of packages required for the build steps that may not be installed by default. For information about the required packages, see the "BuildRequires:" lines in ndctl.spec.in. https://github.com/pmem/ndctl/blob/master/ndctl.spec.in Documentation ============= See the latest documentation for the NVDIMM kernel sub-system here: https://git.kernel.org/cgit/linux/kernel/git/nvdimm/nvdimm.git/tree/Documentation/nvdimm/nvdimm.txt?h=libnvdimm-for-next A getting started guide is also available on the kernel.org nvdimm wiki: https://nvdimm.wiki.kernel.org/start Unit Tests ========== The unit tests run by `make check` require the nfit_test.ko module to be loaded. To build and install nfit_test.ko: 1. Obtain the kernel source. For example, `git clone -b libnvdimm-for-next git://git.kernel.org/pub/scm/linux/kernel/git/nvdimm/nvdimm.git` 1. Skip to step 3 if the kernel version is >= v4.8. Otherwise, for kernel versions < v4.8, configure the kernel to make some memory available to CMA (contiguous memory allocator). This will be used to emulate DAX. ``` CONFIG_DMA_CMA=y CONFIG_CMA_SIZE_MBYTES=200 ``` **or** `cma=200M` on the kernel command line. 1. Compile the libnvdimm sub-system as a module, make sure "zone device" memory is enabled, and enable the btt, pfn, and dax features of the sub-system: ``` CONFIG_X86_PMEM_LEGACY=m CONFIG_ZONE_DEVICE=y CONFIG_LIBNVDIMM=m CONFIG_BLK_DEV_PMEM=m CONFIG_ND_BLK=m CONFIG_BTT=y CONFIG_NVDIMM_PFN=y CONFIG_NVDIMM_DAX=y CONFIG_DEV_DAX_PMEM=m ``` 1. Build and install the unit test enabled libnvdimm modules in the following order. The unit test modules need to be in place prior to the `depmod` that runs during the final `modules_install` ``` make M=tools/testing/nvdimm sudo make M=tools/testing/nvdimm modules_install sudo make modules_install ``` 1. Now run `make check` in the ndctl source directory, or `ndctl test`, if ndctl was built with `--enable-test`. Troubleshooting =============== The unit tests will validate that the environment is set up correctly before they try to run. If the platform is misconfigured, i.e. the unit test modules are not available, or the test versions of the modules are superseded by the "in-tree/production" version of the modules `make check` will skip tests and report a message like the following in test/test-suite.log: ``` SKIP: libndctl ============== test/init: nfit_test_init: nfit.ko: appears to be production version: /lib/modules/4.8.8-200.fc24.x86_64/kernel/drivers/acpi/nfit/nfit.ko.xz __ndctl_test_skip: explicit skip test_libndctl:2684 nfit_test unavailable skipping tests ``` If the unit test modules are indeed available in the modules 'extra' directory the default depmod policy can be overridden by adding a file to /etc/depmod.d with the following contents: ``` override nfit * extra override device_dax * extra override dax_pmem * extra override libnvdimm * extra override nd_blk * extra override nd_btt * extra override nd_e820 * extra override nd_pmem * extra ``` The nfit_test module emulates pmem with memory allocated via vmalloc(). One of the side effects is that this breaks 'physically contiguous' assumptions in the driver. Use the '--align=4K option to 'ndctl create-namespace' to avoid these corner case scenarios. ndctl-61.2/autogen.sh000077500000000000000000000014261331777607200145670ustar00rootroot00000000000000#!/bin/sh -e if [ -f .git/hooks/pre-commit.sample -a ! -f .git/hooks/pre-commit ] ; then cp -p .git/hooks/pre-commit.sample .git/hooks/pre-commit && \ chmod +x .git/hooks/pre-commit && \ echo "Activated pre-commit hook." fi $(dirname $0)/git-version-gen reconf_args='' [ -n "$*" ] && reconf_args="$*" autoreconf --install --symlink $reconf_args libdir() { echo $(cd $1/$(gcc -print-multi-os-directory); pwd) } args="--prefix=/usr \ --sysconfdir=/etc \ --libdir=$(libdir /usr/lib)" echo echo "----------------------------------------------------------------" echo "Initialized build system. For a common configuration please run:" echo "----------------------------------------------------------------" echo echo "./configure CFLAGS='-g -O2' $args" echo ndctl-61.2/builtin.h000066400000000000000000000043071331777607200144060ustar00rootroot00000000000000/* * Copyright(c) 2015-2017 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify it * under the terms of version 2 of the GNU General Public License as * published by the Free Software Foundation. * * 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 * General Public License for more details. */ #ifndef _NDCTL_BUILTIN_H_ #define _NDCTL_BUILTIN_H_ extern const char ndctl_usage_string[]; extern const char ndctl_more_info_string[]; struct cmd_struct { const char *cmd; int (*fn)(int, const char **, void *ctx); }; int cmd_create_nfit(int argc, const char **argv, void *ctx); int cmd_enable_namespace(int argc, const char **argv, void *ctx); int cmd_create_namespace(int argc, const char **argv, void *ctx); int cmd_destroy_namespace(int argc, const char **argv, void *ctx); int cmd_disable_namespace(int argc, const char **argv, void *ctx); int cmd_check_namespace(int argc, const char **argv, void *ctx); int cmd_enable_region(int argc, const char **argv, void *ctx); int cmd_disable_region(int argc, const char **argv, void *ctx); int cmd_enable_dimm(int argc, const char **argv, void *ctx); int cmd_disable_dimm(int argc, const char **argv, void *ctx); int cmd_zero_labels(int argc, const char **argv, void *ctx); int cmd_read_labels(int argc, const char **argv, void *ctx); int cmd_write_labels(int argc, const char **argv, void *ctx); int cmd_init_labels(int argc, const char **argv, void *ctx); int cmd_check_labels(int argc, const char **argv, void *ctx); int cmd_inject_error(int argc, const char **argv, void *ctx); int cmd_wait_scrub(int argc, const char **argv, void *ctx); int cmd_start_scrub(int argc, const char **argv, void *ctx); int cmd_list(int argc, const char **argv, void *ctx); #ifdef ENABLE_TEST int cmd_test(int argc, const char **argv, void *ctx); #endif #ifdef ENABLE_DESTRUCTIVE int cmd_bat(int argc, const char **argv, void *ctx); #endif int cmd_update_firmware(int argc, const char **argv, void *ctx); int cmd_inject_smart(int argc, const char **argv, void *ctx); #endif /* _NDCTL_BUILTIN_H_ */ ndctl-61.2/ccan/000077500000000000000000000000001331777607200134675ustar00rootroot00000000000000ndctl-61.2/ccan/array_size/000077500000000000000000000000001331777607200156375ustar00rootroot00000000000000ndctl-61.2/ccan/array_size/LICENSE000077700000000000000000000000001331777607200213622../../licenses/CC0ustar00rootroot00000000000000ndctl-61.2/ccan/array_size/array_size.h000066400000000000000000000015711331777607200201640ustar00rootroot00000000000000/* CC0 (Public domain) - see LICENSE file for details */ #ifndef CCAN_ARRAY_SIZE_H #define CCAN_ARRAY_SIZE_H #include "config.h" #include /** * ARRAY_SIZE - get the number of elements in a visible array * @arr: the array whose size you want. * * This does not work on pointers, or arrays declared as [], or * function parameters. With correct compiler support, such usage * will cause a build error (see build_assert). */ #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]) + _array_size_chk(arr)) #if HAVE_BUILTIN_TYPES_COMPATIBLE_P && HAVE_TYPEOF /* Two gcc extensions. * &a[0] degrades to a pointer: a different type from an array */ #define _array_size_chk(arr) \ BUILD_ASSERT_OR_ZERO(!__builtin_types_compatible_p(typeof(arr), \ typeof(&(arr)[0]))) #else #define _array_size_chk(arr) 0 #endif #endif /* CCAN_ALIGNOF_H */ ndctl-61.2/ccan/build_assert/000077500000000000000000000000001331777607200161475ustar00rootroot00000000000000ndctl-61.2/ccan/build_assert/LICENSE000077700000000000000000000000001331777607200216722../../licenses/CC0ustar00rootroot00000000000000ndctl-61.2/ccan/build_assert/build_assert.h000066400000000000000000000023141331777607200210000ustar00rootroot00000000000000/* CC0 (Public domain) - see LICENSE file for details */ #ifndef CCAN_BUILD_ASSERT_H #define CCAN_BUILD_ASSERT_H /** * BUILD_ASSERT - assert a build-time dependency. * @cond: the compile-time condition which must be true. * * Your compile will fail if the condition isn't true, or can't be evaluated * by the compiler. This can only be used within a function. * * Example: * #include * ... * static char *foo_to_char(struct foo *foo) * { * // This code needs string to be at start of foo. * BUILD_ASSERT(offsetof(struct foo, string) == 0); * return (char *)foo; * } */ #define BUILD_ASSERT(cond) \ do { (void) sizeof(char [1 - 2*!(cond)]); } while(0) /** * BUILD_ASSERT_OR_ZERO - assert a build-time dependency, as an expression. * @cond: the compile-time condition which must be true. * * Your compile will fail if the condition isn't true, or can't be evaluated * by the compiler. This can be used in an expression: its value is "0". * * Example: * #define foo_to_char(foo) \ * ((char *)(foo) \ * + BUILD_ASSERT_OR_ZERO(offsetof(struct foo, string) == 0)) */ #define BUILD_ASSERT_OR_ZERO(cond) \ (sizeof(char [1 - 2*!(cond)]) - 1) #endif /* CCAN_BUILD_ASSERT_H */ ndctl-61.2/ccan/check_type/000077500000000000000000000000001331777607200156055ustar00rootroot00000000000000ndctl-61.2/ccan/check_type/LICENSE000077700000000000000000000000001331777607200213302../../licenses/CC0ustar00rootroot00000000000000ndctl-61.2/ccan/check_type/check_type.h000066400000000000000000000045051331777607200201000ustar00rootroot00000000000000/* CC0 (Public domain) - see LICENSE file for details */ #ifndef CCAN_CHECK_TYPE_H #define CCAN_CHECK_TYPE_H #include "config.h" /** * check_type - issue a warning or build failure if type is not correct. * @expr: the expression whose type we should check (not evaluated). * @type: the exact type we expect the expression to be. * * This macro is usually used within other macros to try to ensure that a macro * argument is of the expected type. No type promotion of the expression is * done: an unsigned int is not the same as an int! * * check_type() always evaluates to 0. * * If your compiler does not support typeof, then the best we can do is fail * to compile if the sizes of the types are unequal (a less complete check). * * Example: * // They should always pass a 64-bit value to _set_some_value! * #define set_some_value(expr) \ * _set_some_value((check_type((expr), uint64_t), (expr))) */ /** * check_types_match - issue a warning or build failure if types are not same. * @expr1: the first expression (not evaluated). * @expr2: the second expression (not evaluated). * * This macro is usually used within other macros to try to ensure that * arguments are of identical types. No type promotion of the expressions is * done: an unsigned int is not the same as an int! * * check_types_match() always evaluates to 0. * * If your compiler does not support typeof, then the best we can do is fail * to compile if the sizes of the types are unequal (a less complete check). * * Example: * // Do subtraction to get to enclosing type, but make sure that * // pointer is of correct type for that member. * #define container_of(mbr_ptr, encl_type, mbr) \ * (check_types_match((mbr_ptr), &((encl_type *)0)->mbr), \ * ((encl_type *) \ * ((char *)(mbr_ptr) - offsetof(enclosing_type, mbr)))) */ #if HAVE_TYPEOF #define check_type(expr, type) \ ((typeof(expr) *)0 != (type *)0) #define check_types_match(expr1, expr2) \ ((typeof(expr1) *)0 != (typeof(expr2) *)0) #else #include /* Without typeof, we can only test the sizes. */ #define check_type(expr, type) \ BUILD_ASSERT_OR_ZERO(sizeof(expr) == sizeof(type)) #define check_types_match(expr1, expr2) \ BUILD_ASSERT_OR_ZERO(sizeof(expr1) == sizeof(expr2)) #endif /* HAVE_TYPEOF */ #endif /* CCAN_CHECK_TYPE_H */ ndctl-61.2/ccan/container_of/000077500000000000000000000000001331777607200161355ustar00rootroot00000000000000ndctl-61.2/ccan/container_of/LICENSE000077700000000000000000000000001331777607200216602../../licenses/CC0ustar00rootroot00000000000000ndctl-61.2/ccan/container_of/container_of.h000066400000000000000000000061341331777607200207600ustar00rootroot00000000000000/* CC0 (Public domain) - see LICENSE file for details */ #ifndef CCAN_CONTAINER_OF_H #define CCAN_CONTAINER_OF_H #include #include "config.h" #include /** * container_of - get pointer to enclosing structure * @member_ptr: pointer to the structure member * @containing_type: the type this member is within * @member: the name of this member within the structure. * * Given a pointer to a member of a structure, this macro does pointer * subtraction to return the pointer to the enclosing type. * * Example: * struct foo { * int fielda, fieldb; * // ... * }; * struct info { * int some_other_field; * struct foo my_foo; * }; * * static struct info *foo_to_info(struct foo *foo) * { * return container_of(foo, struct info, my_foo); * } */ #define container_of(member_ptr, containing_type, member) \ ((containing_type *) \ ((char *)(member_ptr) \ - container_off(containing_type, member)) \ + check_types_match(*(member_ptr), ((containing_type *)0)->member)) /** * container_off - get offset to enclosing structure * @containing_type: the type this member is within * @member: the name of this member within the structure. * * Given a pointer to a member of a structure, this macro does * typechecking and figures out the offset to the enclosing type. * * Example: * struct foo { * int fielda, fieldb; * // ... * }; * struct info { * int some_other_field; * struct foo my_foo; * }; * * static struct info *foo_to_info(struct foo *foo) * { * size_t off = container_off(struct info, my_foo); * return (void *)((char *)foo - off); * } */ #define container_off(containing_type, member) \ offsetof(containing_type, member) /** * container_of_var - get pointer to enclosing structure using a variable * @member_ptr: pointer to the structure member * @container_var: a pointer of same type as this member's container * @member: the name of this member within the structure. * * Given a pointer to a member of a structure, this macro does pointer * subtraction to return the pointer to the enclosing type. * * Example: * static struct info *foo_to_i(struct foo *foo) * { * struct info *i = container_of_var(foo, i, my_foo); * return i; * } */ #if HAVE_TYPEOF #define container_of_var(member_ptr, container_var, member) \ container_of(member_ptr, typeof(*container_var), member) #else #define container_of_var(member_ptr, container_var, member) \ ((void *)((char *)(member_ptr) - \ container_off_var(container_var, member))) #endif /** * container_off_var - get offset of a field in enclosing structure * @container_var: a pointer to a container structure * @member: the name of a member within the structure. * * Given (any) pointer to a structure and a its member name, this * macro does pointer subtraction to return offset of member in a * structure memory layout. * */ #if HAVE_TYPEOF #define container_off_var(var, member) \ container_off(typeof(*var), member) #else #define container_off_var(var, member) \ ((const char *)&(var)->member - (const char *)(var)) #endif #endif /* CCAN_CONTAINER_OF_H */ ndctl-61.2/ccan/endian/000077500000000000000000000000001331777607200147255ustar00rootroot00000000000000ndctl-61.2/ccan/endian/LICENSE000077700000000000000000000000001331777607200204502../../licenses/CC0ustar00rootroot00000000000000ndctl-61.2/ccan/endian/endian.h000066400000000000000000000220031331777607200163310ustar00rootroot00000000000000/* CC0 (Public domain) - see LICENSE file for details */ #ifndef CCAN_ENDIAN_H #define CCAN_ENDIAN_H #include #include "config.h" /** * BSWAP_16 - reverse bytes in a constant uint16_t value. * @val: constant value whose bytes to swap. * * Designed to be usable in constant-requiring initializers. * * Example: * struct mystruct { * char buf[BSWAP_16(0x1234)]; * }; */ #define BSWAP_16(val) \ ((((uint16_t)(val) & 0x00ff) << 8) \ | (((uint16_t)(val) & 0xff00) >> 8)) /** * BSWAP_32 - reverse bytes in a constant uint32_t value. * @val: constant value whose bytes to swap. * * Designed to be usable in constant-requiring initializers. * * Example: * struct mystruct { * char buf[BSWAP_32(0xff000000)]; * }; */ #define BSWAP_32(val) \ ((((uint32_t)(val) & 0x000000ff) << 24) \ | (((uint32_t)(val) & 0x0000ff00) << 8) \ | (((uint32_t)(val) & 0x00ff0000) >> 8) \ | (((uint32_t)(val) & 0xff000000) >> 24)) /** * BSWAP_64 - reverse bytes in a constant uint64_t value. * @val: constantvalue whose bytes to swap. * * Designed to be usable in constant-requiring initializers. * * Example: * struct mystruct { * char buf[BSWAP_64(0xff00000000000000ULL)]; * }; */ #define BSWAP_64(val) \ ((((uint64_t)(val) & 0x00000000000000ffULL) << 56) \ | (((uint64_t)(val) & 0x000000000000ff00ULL) << 40) \ | (((uint64_t)(val) & 0x0000000000ff0000ULL) << 24) \ | (((uint64_t)(val) & 0x00000000ff000000ULL) << 8) \ | (((uint64_t)(val) & 0x000000ff00000000ULL) >> 8) \ | (((uint64_t)(val) & 0x0000ff0000000000ULL) >> 24) \ | (((uint64_t)(val) & 0x00ff000000000000ULL) >> 40) \ | (((uint64_t)(val) & 0xff00000000000000ULL) >> 56)) #if HAVE_BYTESWAP_H #include #else /** * bswap_16 - reverse bytes in a uint16_t value. * @val: value whose bytes to swap. * * Example: * // Output contains "1024 is 4 as two bytes reversed" * printf("1024 is %u as two bytes reversed\n", bswap_16(1024)); */ static inline uint16_t bswap_16(uint16_t val) { return BSWAP_16(val); } /** * bswap_32 - reverse bytes in a uint32_t value. * @val: value whose bytes to swap. * * Example: * // Output contains "1024 is 262144 as four bytes reversed" * printf("1024 is %u as four bytes reversed\n", bswap_32(1024)); */ static inline uint32_t bswap_32(uint32_t val) { return BSWAP_32(val); } #endif /* !HAVE_BYTESWAP_H */ #if !HAVE_BSWAP_64 /** * bswap_64 - reverse bytes in a uint64_t value. * @val: value whose bytes to swap. * * Example: * // Output contains "1024 is 1125899906842624 as eight bytes reversed" * printf("1024 is %llu as eight bytes reversed\n", * (unsigned long long)bswap_64(1024)); */ static inline uint64_t bswap_64(uint64_t val) { return BSWAP_64(val); } #endif /* Sanity check the defines. We don't handle weird endianness. */ #if !HAVE_LITTLE_ENDIAN && !HAVE_BIG_ENDIAN #error "Unknown endian" #elif HAVE_LITTLE_ENDIAN && HAVE_BIG_ENDIAN #error "Can't compile for both big and little endian." #endif #ifdef __CHECKER__ /* sparse needs forcing to remove bitwise attribute from ccan/short_types */ #define ENDIAN_CAST __attribute__((force)) #define ENDIAN_TYPE __attribute__((bitwise)) #else #define ENDIAN_CAST #define ENDIAN_TYPE #endif typedef uint64_t ENDIAN_TYPE leint64_t; typedef uint64_t ENDIAN_TYPE beint64_t; typedef uint32_t ENDIAN_TYPE leint32_t; typedef uint32_t ENDIAN_TYPE beint32_t; typedef uint16_t ENDIAN_TYPE leint16_t; typedef uint16_t ENDIAN_TYPE beint16_t; #if HAVE_LITTLE_ENDIAN /** * CPU_TO_LE64 - convert a constant uint64_t value to little-endian * @native: constant to convert */ #define CPU_TO_LE64(native) ((ENDIAN_CAST leint64_t)(native)) /** * CPU_TO_LE32 - convert a constant uint32_t value to little-endian * @native: constant to convert */ #define CPU_TO_LE32(native) ((ENDIAN_CAST leint32_t)(native)) /** * CPU_TO_LE16 - convert a constant uint16_t value to little-endian * @native: constant to convert */ #define CPU_TO_LE16(native) ((ENDIAN_CAST leint16_t)(native)) /** * LE64_TO_CPU - convert a little-endian uint64_t constant * @le_val: little-endian constant to convert */ #define LE64_TO_CPU(le_val) ((ENDIAN_CAST uint64_t)(le_val)) /** * LE32_TO_CPU - convert a little-endian uint32_t constant * @le_val: little-endian constant to convert */ #define LE32_TO_CPU(le_val) ((ENDIAN_CAST uint32_t)(le_val)) /** * LE16_TO_CPU - convert a little-endian uint16_t constant * @le_val: little-endian constant to convert */ #define LE16_TO_CPU(le_val) ((ENDIAN_CAST uint16_t)(le_val)) #else /* ... HAVE_BIG_ENDIAN */ #define CPU_TO_LE64(native) ((ENDIAN_CAST leint64_t)BSWAP_64(native)) #define CPU_TO_LE32(native) ((ENDIAN_CAST leint32_t)BSWAP_32(native)) #define CPU_TO_LE16(native) ((ENDIAN_CAST leint16_t)BSWAP_16(native)) #define LE64_TO_CPU(le_val) BSWAP_64((ENDIAN_CAST uint64_t)le_val) #define LE32_TO_CPU(le_val) BSWAP_32((ENDIAN_CAST uint32_t)le_val) #define LE16_TO_CPU(le_val) BSWAP_16((ENDIAN_CAST uint16_t)le_val) #endif /* HAVE_BIG_ENDIAN */ #if HAVE_BIG_ENDIAN /** * CPU_TO_BE64 - convert a constant uint64_t value to big-endian * @native: constant to convert */ #define CPU_TO_BE64(native) ((ENDIAN_CAST beint64_t)(native)) /** * CPU_TO_BE32 - convert a constant uint32_t value to big-endian * @native: constant to convert */ #define CPU_TO_BE32(native) ((ENDIAN_CAST beint32_t)(native)) /** * CPU_TO_BE16 - convert a constant uint16_t value to big-endian * @native: constant to convert */ #define CPU_TO_BE16(native) ((ENDIAN_CAST beint16_t)(native)) /** * BE64_TO_CPU - convert a big-endian uint64_t constant * @le_val: big-endian constant to convert */ #define BE64_TO_CPU(le_val) ((ENDIAN_CAST uint64_t)(le_val)) /** * BE32_TO_CPU - convert a big-endian uint32_t constant * @le_val: big-endian constant to convert */ #define BE32_TO_CPU(le_val) ((ENDIAN_CAST uint32_t)(le_val)) /** * BE16_TO_CPU - convert a big-endian uint16_t constant * @le_val: big-endian constant to convert */ #define BE16_TO_CPU(le_val) ((ENDIAN_CAST uint16_t)(le_val)) #else /* ... HAVE_LITTLE_ENDIAN */ #define CPU_TO_BE64(native) ((ENDIAN_CAST beint64_t)BSWAP_64(native)) #define CPU_TO_BE32(native) ((ENDIAN_CAST beint32_t)BSWAP_32(native)) #define CPU_TO_BE16(native) ((ENDIAN_CAST beint16_t)BSWAP_16(native)) #define BE64_TO_CPU(le_val) BSWAP_64((ENDIAN_CAST uint64_t)le_val) #define BE32_TO_CPU(le_val) BSWAP_32((ENDIAN_CAST uint32_t)le_val) #define BE16_TO_CPU(le_val) BSWAP_16((ENDIAN_CAST uint16_t)le_val) #endif /* HAVE_LITTE_ENDIAN */ /** * cpu_to_le64 - convert a uint64_t value to little-endian * @native: value to convert */ static inline leint64_t cpu_to_le64(uint64_t native) { return CPU_TO_LE64(native); } /** * cpu_to_le32 - convert a uint32_t value to little-endian * @native: value to convert */ static inline leint32_t cpu_to_le32(uint32_t native) { return CPU_TO_LE32(native); } /** * cpu_to_le16 - convert a uint16_t value to little-endian * @native: value to convert */ static inline leint16_t cpu_to_le16(uint16_t native) { return CPU_TO_LE16(native); } /** * le64_to_cpu - convert a little-endian uint64_t value * @le_val: little-endian value to convert */ static inline uint64_t le64_to_cpu(leint64_t le_val) { return LE64_TO_CPU(le_val); } /** * le32_to_cpu - convert a little-endian uint32_t value * @le_val: little-endian value to convert */ static inline uint32_t le32_to_cpu(leint32_t le_val) { return LE32_TO_CPU(le_val); } /** * le16_to_cpu - convert a little-endian uint16_t value * @le_val: little-endian value to convert */ static inline uint16_t le16_to_cpu(leint16_t le_val) { return LE16_TO_CPU(le_val); } /** * cpu_to_be64 - convert a uint64_t value to big endian. * @native: value to convert */ static inline beint64_t cpu_to_be64(uint64_t native) { return ((ENDIAN_CAST beint64_t)BSWAP_64(native)); return CPU_TO_BE64(native); } /** * cpu_to_be32 - convert a uint32_t value to big endian. * @native: value to convert */ static inline beint32_t cpu_to_be32(uint32_t native) { return CPU_TO_BE32(native); } /** * cpu_to_be16 - convert a uint16_t value to big endian. * @native: value to convert */ static inline beint16_t cpu_to_be16(uint16_t native) { return CPU_TO_BE16(native); } /** * be64_to_cpu - convert a big-endian uint64_t value * @be_val: big-endian value to convert */ static inline uint64_t be64_to_cpu(beint64_t be_val) { return BE64_TO_CPU(be_val); } /** * be32_to_cpu - convert a big-endian uint32_t value * @be_val: big-endian value to convert */ static inline uint32_t be32_to_cpu(beint32_t be_val) { return BE32_TO_CPU(be_val); } /** * be16_to_cpu - convert a big-endian uint16_t value * @be_val: big-endian value to convert */ static inline uint16_t be16_to_cpu(beint16_t be_val) { return BE16_TO_CPU(be_val); } /* Whichever they include first, they get these definitions. */ #ifdef CCAN_SHORT_TYPES_H /** * be64/be32/be16 - 64/32/16 bit big-endian representation. */ typedef beint64_t be64; typedef beint32_t be32; typedef beint16_t be16; /** * le64/le32/le16 - 64/32/16 bit little-endian representation. */ typedef leint64_t le64; typedef leint32_t le32; typedef leint16_t le16; #endif #endif /* CCAN_ENDIAN_H */ ndctl-61.2/ccan/list/000077500000000000000000000000001331777607200144425ustar00rootroot00000000000000ndctl-61.2/ccan/list/LICENSE000077700000000000000000000000001331777607200206572../../licenses/BSD-MITustar00rootroot00000000000000ndctl-61.2/ccan/list/list.c000066400000000000000000000017501331777607200155640ustar00rootroot00000000000000/* Licensed under BSD-MIT - see LICENSE file for details */ #include #include #include "list.h" static void *corrupt(const char *abortstr, const struct list_node *head, const struct list_node *node, unsigned int count) { if (abortstr) { fprintf(stderr, "%s: prev corrupt in node %p (%u) of %p\n", abortstr, node, count, head); abort(); } return NULL; } struct list_node *list_check_node(const struct list_node *node, const char *abortstr) { const struct list_node *p, *n; int count = 0; for (p = node, n = node->next; n != node; p = n, n = n->next) { count++; if (n->prev != p) return corrupt(abortstr, node, n, count); } /* Check prev on head node. */ if (node->prev != p) return corrupt(abortstr, node, node, 0); return (struct list_node *)node; } struct list_head *list_check(const struct list_head *h, const char *abortstr) { if (!list_check_node(&h->n, abortstr)) return NULL; return (struct list_head *)h; } ndctl-61.2/ccan/list/list.h000066400000000000000000000447171331777607200156030ustar00rootroot00000000000000/* Licensed under BSD-MIT - see LICENSE file for details */ #ifndef CCAN_LIST_H #define CCAN_LIST_H //#define CCAN_LIST_DEBUG 1 #include #include #include #include #include /** * struct list_node - an entry in a doubly-linked list * @next: next entry (self if empty) * @prev: previous entry (self if empty) * * This is used as an entry in a linked list. * Example: * struct child { * const char *name; * // Linked list of all us children. * struct list_node list; * }; */ struct list_node { struct list_node *next, *prev; }; /** * struct list_head - the head of a doubly-linked list * @h: the list_head (containing next and prev pointers) * * This is used as the head of a linked list. * Example: * struct parent { * const char *name; * struct list_head children; * unsigned int num_children; * }; */ struct list_head { struct list_node n; }; /** * list_check - check head of a list for consistency * @h: the list_head * @abortstr: the location to print on aborting, or NULL. * * Because list_nodes have redundant information, consistency checking between * the back and forward links can be done. This is useful as a debugging check. * If @abortstr is non-NULL, that will be printed in a diagnostic if the list * is inconsistent, and the function will abort. * * Returns the list head if the list is consistent, NULL if not (it * can never return NULL if @abortstr is set). * * See also: list_check_node() * * Example: * static void dump_parent(struct parent *p) * { * struct child *c; * * printf("%s (%u children):\n", p->name, p->num_children); * list_check(&p->children, "bad child list"); * list_for_each(&p->children, c, list) * printf(" -> %s\n", c->name); * } */ struct list_head *list_check(const struct list_head *h, const char *abortstr); /** * list_check_node - check node of a list for consistency * @n: the list_node * @abortstr: the location to print on aborting, or NULL. * * Check consistency of the list node is in (it must be in one). * * See also: list_check() * * Example: * static void dump_child(const struct child *c) * { * list_check_node(&c->list, "bad child list"); * printf("%s\n", c->name); * } */ struct list_node *list_check_node(const struct list_node *n, const char *abortstr); #define LIST_LOC __FILE__ ":" stringify(__LINE__) #ifdef CCAN_LIST_DEBUG #define list_debug(h, loc) list_check((h), loc) #define list_debug_node(n, loc) list_check_node((n), loc) #else #define list_debug(h, loc) (h) #define list_debug_node(n, loc) (n) #endif /** * LIST_HEAD_INIT - initializer for an empty list_head * @name: the name of the list. * * Explicit initializer for an empty list. * * See also: * LIST_HEAD, list_head_init() * * Example: * static struct list_head my_list = LIST_HEAD_INIT(my_list); */ #define LIST_HEAD_INIT(name) { { &name.n, &name.n } } /** * LIST_HEAD - define and initialize an empty list_head * @name: the name of the list. * * The LIST_HEAD macro defines a list_head and initializes it to an empty * list. It can be prepended by "static" to define a static list_head. * * See also: * LIST_HEAD_INIT, list_head_init() * * Example: * static LIST_HEAD(my_global_list); */ #define LIST_HEAD(name) \ struct list_head name = LIST_HEAD_INIT(name) /** * list_head_init - initialize a list_head * @h: the list_head to set to the empty list * * Example: * ... * struct parent *parent = malloc(sizeof(*parent)); * * list_head_init(&parent->children); * parent->num_children = 0; */ static inline void list_head_init(struct list_head *h) { h->n.next = h->n.prev = &h->n; } /** * list_add - add an entry at the start of a linked list. * @h: the list_head to add the node to * @n: the list_node to add to the list. * * The list_node does not need to be initialized; it will be overwritten. * Example: * struct child *child = malloc(sizeof(*child)); * * child->name = "marvin"; * list_add(&parent->children, &child->list); * parent->num_children++; */ #define list_add(h, n) list_add_(h, n, LIST_LOC) static inline void list_add_(struct list_head *h, struct list_node *n, const char *abortstr) { n->next = h->n.next; n->prev = &h->n; h->n.next->prev = n; h->n.next = n; (void)list_debug(h, abortstr); } /** * list_add_tail - add an entry at the end of a linked list. * @h: the list_head to add the node to * @n: the list_node to add to the list. * * The list_node does not need to be initialized; it will be overwritten. * Example: * list_add_tail(&parent->children, &child->list); * parent->num_children++; */ #define list_add_tail(h, n) list_add_tail_(h, n, LIST_LOC) static inline void list_add_tail_(struct list_head *h, struct list_node *n, const char *abortstr) { n->next = &h->n; n->prev = h->n.prev; h->n.prev->next = n; h->n.prev = n; (void)list_debug(h, abortstr); } /** * list_empty - is a list empty? * @h: the list_head * * If the list is empty, returns true. * * Example: * assert(list_empty(&parent->children) == (parent->num_children == 0)); */ #define list_empty(h) list_empty_(h, LIST_LOC) static inline bool list_empty_(const struct list_head *h, const char* abortstr) { (void)list_debug(h, abortstr); return h->n.next == &h->n; } /** * list_empty_nodebug - is a list empty (and don't perform debug checks)? * @h: the list_head * * If the list is empty, returns true. * This differs from list_empty() in that if CCAN_LIST_DEBUG is set it * will NOT perform debug checks. Only use this function if you REALLY * know what you're doing. * * Example: * assert(list_empty_nodebug(&parent->children) == (parent->num_children == 0)); */ #ifndef CCAN_LIST_DEBUG #define list_empty_nodebug(h) list_empty(h) #else static inline bool list_empty_nodebug(const struct list_head *h) { return h->n.next == &h->n; } #endif /** * list_del - delete an entry from an (unknown) linked list. * @n: the list_node to delete from the list. * * Note that this leaves @n in an undefined state; it can be added to * another list, but not deleted again. * * See also: * list_del_from() * * Example: * list_del(&child->list); * parent->num_children--; */ #define list_del(n) list_del_(n, LIST_LOC) static inline void list_del_(struct list_node *n, const char* abortstr) { (void)list_debug_node(n, abortstr); n->next->prev = n->prev; n->prev->next = n->next; #ifdef CCAN_LIST_DEBUG /* Catch use-after-del. */ n->next = n->prev = NULL; #endif } /** * list_del_from - delete an entry from a known linked list. * @h: the list_head the node is in. * @n: the list_node to delete from the list. * * This explicitly indicates which list a node is expected to be in, * which is better documentation and can catch more bugs. * * See also: list_del() * * Example: * list_del_from(&parent->children, &child->list); * parent->num_children--; */ static inline void list_del_from(struct list_head *h, struct list_node *n) { #ifdef CCAN_LIST_DEBUG { /* Thorough check: make sure it was in list! */ struct list_node *i; for (i = h->n.next; i != n; i = i->next) assert(i != &h->n); } #endif /* CCAN_LIST_DEBUG */ /* Quick test that catches a surprising number of bugs. */ assert(!list_empty(h)); list_del(n); } /** * list_entry - convert a list_node back into the structure containing it. * @n: the list_node * @type: the type of the entry * @member: the list_node member of the type * * Example: * // First list entry is children.next; convert back to child. * child = list_entry(parent->children.n.next, struct child, list); * * See Also: * list_top(), list_for_each() */ #define list_entry(n, type, member) container_of(n, type, member) /** * list_top - get the first entry in a list * @h: the list_head * @type: the type of the entry * @member: the list_node member of the type * * If the list is empty, returns NULL. * * Example: * struct child *first; * first = list_top(&parent->children, struct child, list); * if (!first) * printf("Empty list!\n"); */ #define list_top(h, type, member) \ ((type *)list_top_((h), list_off_(type, member))) static inline const void *list_top_(const struct list_head *h, size_t off) { if (list_empty(h)) return NULL; return (const char *)h->n.next - off; } /** * list_pop - remove the first entry in a list * @h: the list_head * @type: the type of the entry * @member: the list_node member of the type * * If the list is empty, returns NULL. * * Example: * struct child *one; * one = list_pop(&parent->children, struct child, list); * if (!one) * printf("Empty list!\n"); */ #define list_pop(h, type, member) \ ((type *)list_pop_((h), list_off_(type, member))) static inline const void *list_pop_(const struct list_head *h, size_t off) { struct list_node *n; if (list_empty(h)) return NULL; n = h->n.next; list_del(n); return (const char *)n - off; } /** * list_tail - get the last entry in a list * @h: the list_head * @type: the type of the entry * @member: the list_node member of the type * * If the list is empty, returns NULL. * * Example: * struct child *last; * last = list_tail(&parent->children, struct child, list); * if (!last) * printf("Empty list!\n"); */ #define list_tail(h, type, member) \ ((type *)list_tail_((h), list_off_(type, member))) static inline const void *list_tail_(const struct list_head *h, size_t off) { if (list_empty(h)) return NULL; return (const char *)h->n.prev - off; } /** * list_for_each - iterate through a list. * @h: the list_head (warning: evaluated multiple times!) * @i: the structure containing the list_node * @member: the list_node member of the structure * * This is a convenient wrapper to iterate @i over the entire list. It's * a for loop, so you can break and continue as normal. * * Example: * list_for_each(&parent->children, child, list) * printf("Name: %s\n", child->name); */ #define list_for_each(h, i, member) \ list_for_each_off(h, i, list_off_var_(i, member)) /** * list_for_each_rev - iterate through a list backwards. * @h: the list_head * @i: the structure containing the list_node * @member: the list_node member of the structure * * This is a convenient wrapper to iterate @i over the entire list. It's * a for loop, so you can break and continue as normal. * * Example: * list_for_each_rev(&parent->children, child, list) * printf("Name: %s\n", child->name); */ #define list_for_each_rev(h, i, member) \ for (i = container_of_var(list_debug(h, LIST_LOC)->n.prev, i, member); \ &i->member != &(h)->n; \ i = container_of_var(i->member.prev, i, member)) /** * list_for_each_safe - iterate through a list, maybe during deletion * @h: the list_head * @i: the structure containing the list_node * @nxt: the structure containing the list_node * @member: the list_node member of the structure * * This is a convenient wrapper to iterate @i over the entire list. It's * a for loop, so you can break and continue as normal. The extra variable * @nxt is used to hold the next element, so you can delete @i from the list. * * Example: * struct child *next; * list_for_each_safe(&parent->children, child, next, list) { * list_del(&child->list); * parent->num_children--; * } */ #define list_for_each_safe(h, i, nxt, member) \ list_for_each_safe_off(h, i, nxt, list_off_var_(i, member)) /** * list_next - get the next entry in a list * @h: the list_head * @i: a pointer to an entry in the list. * @member: the list_node member of the structure * * If @i was the last entry in the list, returns NULL. * * Example: * struct child *second; * second = list_next(&parent->children, first, list); * if (!second) * printf("No second child!\n"); */ #define list_next(h, i, member) \ ((list_typeof(i))list_entry_or_null(list_debug(h, \ __FILE__ ":" stringify(__LINE__)), \ (i)->member.next, \ list_off_var_((i), member))) /** * list_prev - get the previous entry in a list * @h: the list_head * @i: a pointer to an entry in the list. * @member: the list_node member of the structure * * If @i was the first entry in the list, returns NULL. * * Example: * first = list_prev(&parent->children, second, list); * if (!first) * printf("Can't go back to first child?!\n"); */ #define list_prev(h, i, member) \ ((list_typeof(i))list_entry_or_null(list_debug(h, \ __FILE__ ":" stringify(__LINE__)), \ (i)->member.prev, \ list_off_var_((i), member))) /** * list_append_list - empty one list onto the end of another. * @to: the list to append into * @from: the list to empty. * * This takes the entire contents of @from and moves it to the end of * @to. After this @from will be empty. * * Example: * struct list_head adopter; * * list_append_list(&adopter, &parent->children); * assert(list_empty(&parent->children)); * parent->num_children = 0; */ #define list_append_list(t, f) list_append_list_(t, f, \ __FILE__ ":" stringify(__LINE__)) static inline void list_append_list_(struct list_head *to, struct list_head *from, const char *abortstr) { struct list_node *from_tail = list_debug(from, abortstr)->n.prev; struct list_node *to_tail = list_debug(to, abortstr)->n.prev; /* Sew in head and entire list. */ to->n.prev = from_tail; from_tail->next = &to->n; to_tail->next = &from->n; from->n.prev = to_tail; /* Now remove head. */ list_del(&from->n); list_head_init(from); } /** * list_prepend_list - empty one list into the start of another. * @to: the list to prepend into * @from: the list to empty. * * This takes the entire contents of @from and moves it to the start * of @to. After this @from will be empty. * * Example: * list_prepend_list(&adopter, &parent->children); * assert(list_empty(&parent->children)); * parent->num_children = 0; */ #define list_prepend_list(t, f) list_prepend_list_(t, f, LIST_LOC) static inline void list_prepend_list_(struct list_head *to, struct list_head *from, const char *abortstr) { struct list_node *from_tail = list_debug(from, abortstr)->n.prev; struct list_node *to_head = list_debug(to, abortstr)->n.next; /* Sew in head and entire list. */ to->n.next = &from->n; from->n.prev = &to->n; to_head->prev = from_tail; from_tail->next = to_head; /* Now remove head. */ list_del(&from->n); list_head_init(from); } /** * list_for_each_off - iterate through a list of memory regions. * @h: the list_head * @i: the pointer to a memory region wich contains list node data. * @off: offset(relative to @i) at which list node data resides. * * This is a low-level wrapper to iterate @i over the entire list, used to * implement all oher, more high-level, for-each constructs. It's a for loop, * so you can break and continue as normal. * * WARNING! Being the low-level macro that it is, this wrapper doesn't know * nor care about the type of @i. The only assumtion made is that @i points * to a chunk of memory that at some @offset, relative to @i, contains a * properly filled `struct node_list' which in turn contains pointers to * memory chunks and it's turtles all the way down. Whith all that in mind * remember that given the wrong pointer/offset couple this macro will * happilly churn all you memory untill SEGFAULT stops it, in other words * caveat emptor. * * It is worth mentioning that one of legitimate use-cases for that wrapper * is operation on opaque types with known offset for `struct list_node' * member(preferably 0), because it allows you not to disclose the type of * @i. * * Example: * list_for_each_off(&parent->children, child, * offsetof(struct child, list)) * printf("Name: %s\n", child->name); */ #define list_for_each_off(h, i, off) \ for (i = list_node_to_off_(list_debug(h, LIST_LOC)->n.next, \ (off)); \ list_node_from_off_((void *)i, (off)) != &(h)->n; \ i = list_node_to_off_(list_node_from_off_((void *)i, (off))->next, \ (off))) /** * list_for_each_safe_off - iterate through a list of memory regions, maybe * during deletion * @h: the list_head * @i: the pointer to a memory region wich contains list node data. * @nxt: the structure containing the list_node * @off: offset(relative to @i) at which list node data resides. * * For details see `list_for_each_off' and `list_for_each_safe' * descriptions. * * Example: * list_for_each_safe_off(&parent->children, child, * next, offsetof(struct child, list)) * printf("Name: %s\n", child->name); */ #define list_for_each_safe_off(h, i, nxt, off) \ for (i = list_node_to_off_(list_debug(h, LIST_LOC)->n.next, \ (off)), \ nxt = list_node_to_off_(list_node_from_off_(i, (off))->next, \ (off)); \ list_node_from_off_(i, (off)) != &(h)->n; \ i = nxt, \ nxt = list_node_to_off_(list_node_from_off_(i, (off))->next, \ (off))) /* Other -off variants. */ #define list_entry_off(n, type, off) \ ((type *)list_node_from_off_((n), (off))) #define list_head_off(h, type, off) \ ((type *)list_head_off((h), (off))) #define list_tail_off(h, type, off) \ ((type *)list_tail_((h), (off))) #define list_add_off(h, n, off) \ list_add((h), list_node_from_off_((n), (off))) #define list_del_off(n, off) \ list_del(list_node_from_off_((n), (off))) #define list_del_from_off(h, n, off) \ list_del_from(h, list_node_from_off_((n), (off))) /* Offset helper functions so we only single-evaluate. */ static inline void *list_node_to_off_(struct list_node *node, size_t off) { return (void *)((char *)node - off); } static inline struct list_node *list_node_from_off_(void *ptr, size_t off) { return (struct list_node *)((char *)ptr + off); } /* Get the offset of the member, but make sure it's a list_node. */ #define list_off_(type, member) \ (container_off(type, member) + \ check_type(((type *)0)->member, struct list_node)) #define list_off_var_(var, member) \ (container_off_var(var, member) + \ check_type(var->member, struct list_node)) #if HAVE_TYPEOF #define list_typeof(var) typeof(var) #else #define list_typeof(var) void * #endif /* Returns member, or NULL if at end of list. */ static inline void *list_entry_or_null(const struct list_head *h, const struct list_node *n, size_t off) { if (n == &h->n) return NULL; return (char *)n - off; } #endif /* CCAN_LIST_H */ ndctl-61.2/ccan/minmax/000077500000000000000000000000001331777607200147605ustar00rootroot00000000000000ndctl-61.2/ccan/minmax/LICENSE000077700000000000000000000000001331777607200205032../../licenses/CC0ustar00rootroot00000000000000ndctl-61.2/ccan/minmax/minmax.h000066400000000000000000000023721331777607200164260ustar00rootroot00000000000000/* CC0 (Public domain) - see LICENSE file for details */ #ifndef CCAN_MINMAX_H #define CCAN_MINMAX_H #include "config.h" #include #if !HAVE_STATEMENT_EXPR || !HAVE_TYPEOF /* * Without these, there's no way to avoid unsafe double evaluation of * the arguments */ #error Sorry, minmax module requires statement expressions and typeof #endif #if HAVE_BUILTIN_TYPES_COMPATIBLE_P #define MINMAX_ASSERT_COMPATIBLE(a, b) \ BUILD_ASSERT(__builtin_types_compatible_p(a, b)) #else #define MINMAX_ASSERT_COMPATIBLE(a, b) \ do { } while (0) #endif #define min(a, b) \ ({ \ typeof(a) _a = (a); \ typeof(b) _b = (b); \ MINMAX_ASSERT_COMPATIBLE(typeof(_a), typeof(_b)); \ _a < _b ? _a : _b; \ }) #define max(a, b) \ ({ \ typeof(a) __a = (a); \ typeof(b) __b = (b); \ MINMAX_ASSERT_COMPATIBLE(typeof(__a), typeof(__b)); \ __a > __b ? __a : __b; \ }) #define clamp(v, f, c) (max(min((v), (c)), (f))) #define min_t(t, a, b) \ ({ \ t _ta = (a); \ t _tb = (b); \ min(_ta, _tb); \ }) #define max_t(t, a, b) \ ({ \ t _ta = (a); \ t _tb = (b); \ max(_ta, _tb); \ }) #define clamp_t(t, v, f, c) \ ({ \ t _tv = (v); \ t _tf = (f); \ t _tc = (c); \ clamp(_tv, _tf, _tc); \ }) #endif /* CCAN_MINMAX_H */ ndctl-61.2/ccan/short_types/000077500000000000000000000000001331777607200160525ustar00rootroot00000000000000ndctl-61.2/ccan/short_types/LICENSE000077700000000000000000000000001331777607200215752../../licenses/CC0ustar00rootroot00000000000000ndctl-61.2/ccan/short_types/short_types.h000066400000000000000000000014311331777607200206050ustar00rootroot00000000000000/* CC0 (Public domain) - see LICENSE file for details */ #ifndef CCAN_SHORT_TYPES_H #define CCAN_SHORT_TYPES_H #include /** * u64/s64/u32/s32/u16/s16/u8/s8 - short names for explicitly-sized types. */ typedef uint64_t u64; typedef int64_t s64; typedef uint32_t u32; typedef int32_t s32; typedef uint16_t u16; typedef int16_t s16; typedef uint8_t u8; typedef int8_t s8; /* Whichever they include first, they get these definitions. */ #ifdef CCAN_ENDIAN_H /** * be64/be32/be16 - 64/32/16 bit big-endian representation. */ typedef beint64_t be64; typedef beint32_t be32; typedef beint16_t be16; /** * le64/le32/le16 - 64/32/16 bit little-endian representation. */ typedef leint64_t le64; typedef leint32_t le32; typedef leint16_t le16; #endif #endif /* CCAN_SHORT_TYPES_H */ ndctl-61.2/ccan/str/000077500000000000000000000000001331777607200142775ustar00rootroot00000000000000ndctl-61.2/ccan/str/LICENSE000077700000000000000000000000001331777607200200222../../licenses/CC0ustar00rootroot00000000000000ndctl-61.2/ccan/str/debug.c000066400000000000000000000031021331777607200155250ustar00rootroot00000000000000/* CC0 (Public domain) - see LICENSE file for details */ #include "config.h" #include #include #include #include #ifdef CCAN_STR_DEBUG /* Because we mug the real ones with macros, we need our own wrappers. */ int str_isalnum(int i) { assert(i >= -1 && i < 256); return isalnum(i); } int str_isalpha(int i) { assert(i >= -1 && i < 256); return isalpha(i); } int str_isascii(int i) { assert(i >= -1 && i < 256); return isascii(i); } #if HAVE_ISBLANK int str_isblank(int i) { assert(i >= -1 && i < 256); return isblank(i); } #endif int str_iscntrl(int i) { assert(i >= -1 && i < 256); return iscntrl(i); } int str_isdigit(int i) { assert(i >= -1 && i < 256); return isdigit(i); } int str_isgraph(int i) { assert(i >= -1 && i < 256); return isgraph(i); } int str_islower(int i) { assert(i >= -1 && i < 256); return islower(i); } int str_isprint(int i) { assert(i >= -1 && i < 256); return isprint(i); } int str_ispunct(int i) { assert(i >= -1 && i < 256); return ispunct(i); } int str_isspace(int i) { assert(i >= -1 && i < 256); return isspace(i); } int str_isupper(int i) { assert(i >= -1 && i < 256); return isupper(i); } int str_isxdigit(int i) { assert(i >= -1 && i < 256); return isxdigit(i); } #undef strstr #undef strchr #undef strrchr char *str_strstr(const char *haystack, const char *needle) { return strstr(haystack, needle); } char *str_strchr(const char *haystack, int c) { return strchr(haystack, c); } char *str_strrchr(const char *haystack, int c) { return strrchr(haystack, c); } #endif ndctl-61.2/ccan/str/str.c000066400000000000000000000004331331777607200152530ustar00rootroot00000000000000/* CC0 (Public domain) - see LICENSE file for details */ #include size_t strcount(const char *haystack, const char *needle) { size_t i = 0, nlen = strlen(needle); while ((haystack = strstr(haystack, needle)) != NULL) { i++; haystack += nlen; } return i; } ndctl-61.2/ccan/str/str.h000066400000000000000000000135031331777607200152620ustar00rootroot00000000000000/* CC0 (Public domain) - see LICENSE file for details */ #ifndef CCAN_STR_H #define CCAN_STR_H #include "config.h" #include #include #include #include /** * streq - Are two strings equal? * @a: first string * @b: first string * * This macro is arguably more readable than "!strcmp(a, b)". * * Example: * if (streq(somestring, "")) * printf("String is empty!\n"); */ #define streq(a,b) (strcmp((a),(b)) == 0) /** * strstarts - Does this string start with this prefix? * @str: string to test * @prefix: prefix to look for at start of str * * Example: * if (strstarts(somestring, "foo")) * printf("String %s begins with 'foo'!\n", somestring); */ #define strstarts(str,prefix) (strncmp((str),(prefix),strlen(prefix)) == 0) /** * strends - Does this string end with this postfix? * @str: string to test * @postfix: postfix to look for at end of str * * Example: * if (strends(somestring, "foo")) * printf("String %s end with 'foo'!\n", somestring); */ static inline bool strends(const char *str, const char *postfix) { if (strlen(str) < strlen(postfix)) return false; return streq(str + strlen(str) - strlen(postfix), postfix); } /** * stringify - Turn expression into a string literal * @expr: any C expression * * Example: * #define PRINT_COND_IF_FALSE(cond) \ * ((cond) || printf("%s is false!", stringify(cond))) */ #define stringify(expr) stringify_1(expr) /* Double-indirection required to stringify expansions */ #define stringify_1(expr) #expr /** * strcount - Count number of (non-overlapping) occurrences of a substring. * @haystack: a C string * @needle: a substring * * Example: * assert(strcount("aaa aaa", "a") == 6); * assert(strcount("aaa aaa", "ab") == 0); * assert(strcount("aaa aaa", "aa") == 2); */ size_t strcount(const char *haystack, const char *needle); /** * STR_MAX_CHARS - Maximum possible size of numeric string for this type. * @type_or_expr: a pointer or integer type or expression. * * This provides enough space for a nul-terminated string which represents the * largest possible value for the type or expression. * * Note: The implementation adds extra space so hex values or negative * values will fit (eg. sprintf(... "%p"). ) * * Example: * char str[STR_MAX_CHARS(int)]; * * sprintf(str, "%i", 7); */ #define STR_MAX_CHARS(type_or_expr) \ ((sizeof(type_or_expr) * CHAR_BIT + 8) / 9 * 3 + 2 \ + STR_MAX_CHARS_TCHECK_(type_or_expr)) #if HAVE_TYPEOF /* Only a simple type can have 0 assigned, so test that. */ #define STR_MAX_CHARS_TCHECK_(type_or_expr) \ ({ typeof(type_or_expr) x = 0; (void)x; 0; }) #else #define STR_MAX_CHARS_TCHECK_(type_or_expr) 0 #endif /** * cisalnum - isalnum() which takes a char (and doesn't accept EOF) * @c: a character * * Surprisingly, the standard ctype.h isalnum() takes an int, which * must have the value of EOF (-1) or an unsigned char. This variant * takes a real char, and doesn't accept EOF. */ static inline bool cisalnum(char c) { return isalnum((unsigned char)c); } static inline bool cisalpha(char c) { return isalpha((unsigned char)c); } static inline bool cisascii(char c) { return isascii((unsigned char)c); } #if HAVE_ISBLANK static inline bool cisblank(char c) { return isblank((unsigned char)c); } #endif static inline bool ciscntrl(char c) { return iscntrl((unsigned char)c); } static inline bool cisdigit(char c) { return isdigit((unsigned char)c); } static inline bool cisgraph(char c) { return isgraph((unsigned char)c); } static inline bool cislower(char c) { return islower((unsigned char)c); } static inline bool cisprint(char c) { return isprint((unsigned char)c); } static inline bool cispunct(char c) { return ispunct((unsigned char)c); } static inline bool cisspace(char c) { return isspace((unsigned char)c); } static inline bool cisupper(char c) { return isupper((unsigned char)c); } static inline bool cisxdigit(char c) { return isxdigit((unsigned char)c); } #include /* These checks force things out of line, hence they are under DEBUG. */ #ifdef CCAN_STR_DEBUG #include /* These are commonly misused: they take -1 or an *unsigned* char value. */ #undef isalnum #undef isalpha #undef isascii #undef isblank #undef iscntrl #undef isdigit #undef isgraph #undef islower #undef isprint #undef ispunct #undef isspace #undef isupper #undef isxdigit /* You can use a char if char is unsigned. */ #if HAVE_BUILTIN_TYPES_COMPATIBLE_P && HAVE_TYPEOF #define str_check_arg_(i) \ ((i) + BUILD_ASSERT_OR_ZERO(!__builtin_types_compatible_p(typeof(i), \ char) \ || (char)255 > 0)) #else #define str_check_arg_(i) (i) #endif #define isalnum(i) str_isalnum(str_check_arg_(i)) #define isalpha(i) str_isalpha(str_check_arg_(i)) #define isascii(i) str_isascii(str_check_arg_(i)) #if HAVE_ISBLANK #define isblank(i) str_isblank(str_check_arg_(i)) #endif #define iscntrl(i) str_iscntrl(str_check_arg_(i)) #define isdigit(i) str_isdigit(str_check_arg_(i)) #define isgraph(i) str_isgraph(str_check_arg_(i)) #define islower(i) str_islower(str_check_arg_(i)) #define isprint(i) str_isprint(str_check_arg_(i)) #define ispunct(i) str_ispunct(str_check_arg_(i)) #define isspace(i) str_isspace(str_check_arg_(i)) #define isupper(i) str_isupper(str_check_arg_(i)) #define isxdigit(i) str_isxdigit(str_check_arg_(i)) #if HAVE_TYPEOF /* With GNU magic, we can make const-respecting standard string functions. */ #undef strstr #undef strchr #undef strrchr /* + 0 is needed to decay array into pointer. */ #define strstr(haystack, needle) \ ((typeof((haystack) + 0))str_strstr((haystack), (needle))) #define strchr(haystack, c) \ ((typeof((haystack) + 0))str_strchr((haystack), (c))) #define strrchr(haystack, c) \ ((typeof((haystack) + 0))str_strrchr((haystack), (c))) #endif #endif /* CCAN_STR_DEBUG */ #endif /* CCAN_STR_H */ ndctl-61.2/ccan/str/str_debug.h000066400000000000000000000014061331777607200164270ustar00rootroot00000000000000/* CC0 (Public domain) - see LICENSE file for details */ #ifndef CCAN_STR_DEBUG_H #define CCAN_STR_DEBUG_H /* #define CCAN_STR_DEBUG 1 */ #ifdef CCAN_STR_DEBUG /* Because we mug the real ones with macros, we need our own wrappers. */ int str_isalnum(int i); int str_isalpha(int i); int str_isascii(int i); #if HAVE_ISBLANK int str_isblank(int i); #endif int str_iscntrl(int i); int str_isdigit(int i); int str_isgraph(int i); int str_islower(int i); int str_isprint(int i); int str_ispunct(int i); int str_isspace(int i); int str_isupper(int i); int str_isxdigit(int i); char *str_strstr(const char *haystack, const char *needle); char *str_strchr(const char *s, int c); char *str_strrchr(const char *s, int c); #endif /* CCAN_STR_DEBUG */ #endif /* CCAN_STR_DEBUG_H */ ndctl-61.2/configure.ac000066400000000000000000000131051331777607200150510ustar00rootroot00000000000000AC_PREREQ(2.60) m4_include([version.m4]) AC_INIT([ndctl], GIT_VERSION, [linux-nvdimm@lists.01.org], [ndctl], [https://github.com/pmem/ndctl]) AC_CONFIG_SRCDIR([ndctl/lib/libndctl.c]) AC_CONFIG_AUX_DIR([build-aux]) AM_INIT_AUTOMAKE([ check-news foreign 1.11 -Wall -Wno-portability silent-rules tar-pax no-dist-gzip dist-xz subdir-objects ]) AC_PROG_CC_STDC AC_USE_SYSTEM_EXTENSIONS AC_SYS_LARGEFILE AC_CONFIG_MACRO_DIR([m4]) AM_SILENT_RULES([yes]) LT_INIT([ disable-static pic-only ]) AC_PREFIX_DEFAULT([/usr]) AC_PROG_SED AC_PROG_MKDIR_P AC_ARG_ENABLE([docs], AS_HELP_STRING([--disable-docs], [disable documentation build @<:@default=enabled@:>@]), [], enable_docs=yes) AS_IF([test "x$enable_docs" = "xyes"], [ AC_DEFINE(ENABLE_DOCS, [1], [Documentation / man pages.]) ]) AM_CONDITIONAL([ENABLE_DOCS], [test "x$enable_docs" = "xyes"]) AC_ARG_ENABLE([asciidoctor], AS_HELP_STRING([--enable-asciidoctor], [use asciidoctor for documentation build]), [], enable_asciidoctor=no) AM_CONDITIONAL([USE_ASCIIDOCTOR], [test "x$enable_asciidoctor" = "xyes"]) if test "x$enable_asciidoctor" = "xyes"; then asciidoc="asciidoctor" else asciidoc="asciidoc" fi AC_CHECK_PROG(ASCIIDOC, [$asciidoc], [$(which $asciidoc)], [missing]) if test "x$ASCIIDOC" = xmissing -a "x$enable_docs" = "xyes"; then AC_MSG_ERROR([$asciidoc needed to build documentation]) fi AC_SUBST([ASCIIDOC]) if test x"$asciidoc" = x"asciidoc"; then AC_CHECK_PROG(XMLTO, [xmlto], [$(which xmlto)], [missing]) if test "x$XMLTO" = xmissing -a "x$enable_docs" = "xyes"; then AC_MSG_ERROR([xmlto needed to build documentation]) fi AC_SUBST([XMLTO]) fi AC_C_TYPEOF AC_DEFINE([HAVE_STATEMENT_EXPR], 1, [Define to 1 if you have statement expressions.]) AC_C_BIGENDIAN( AC_DEFINE(HAVE_BIG_ENDIAN, 1, [Define to 1 if big-endian-arch]), AC_DEFINE(HAVE_LITTLE_ENDIAN, 1, [Define to 1 if little-endian-arch]), [], []) AC_ARG_ENABLE([logging], AS_HELP_STRING([--disable-logging], [disable system logging @<:@default=enabled@:>@]), [], enable_logging=yes) AS_IF([test "x$enable_logging" = "xyes"], [ AC_DEFINE(ENABLE_LOGGING, [1], [System logging.]) ]) AC_ARG_ENABLE([debug], AS_HELP_STRING([--enable-debug], [enable debug messages @<:@default=disabled@:>@]), [], [enable_debug=no]) AS_IF([test "x$enable_debug" = "xyes"], [ AC_DEFINE(ENABLE_DEBUG, [1], [Debug messages.]) ]) AC_ARG_ENABLE([destructive], AS_HELP_STRING([--enable-destructive], [enable destructive functional tests @<:@default=disabled@:>@]), [], [enable_destructive=no]) AS_IF([test "x$enable_destructive" = "xyes"], [AC_DEFINE([ENABLE_DESTRUCTIVE], [1], [destructive functional tests support])]) AM_CONDITIONAL([ENABLE_DESTRUCTIVE], [test "x$enable_destructive" = "xyes"]) AC_ARG_ENABLE([test], AS_HELP_STRING([--enable-test], [enable ndctl test command @<:@default=disabled@:>@]), [], [enable_test=$enable_destructive]) AS_IF([test "x$enable_test" = "xyes"], [AC_DEFINE([ENABLE_TEST], [1], [ndctl test support])]) AM_CONDITIONAL([ENABLE_TEST], [test "x$enable_test" = "xyes"]) AC_CHECK_DECLS([BUS_MCEERR_AR], [enable_bus_mc_err=yes], [], [[#include ]]) AC_CHECK_DECLS([MAP_SYNC], [enable_map_sync=yes], [], [[#include ]]) AS_IF([test "x$enable_bus_mc_err" = "xyes" -a "x$enable_map_sync" = "xyes"], [AC_DEFINE([ENABLE_POISON], [1], [ndctl test poison support])]) AM_CONDITIONAL([ENABLE_POISON], [test "x$enable_bus_mc_err" = "xyes" -a "x$enable_map_sync" = "xyes"]) PKG_CHECK_MODULES([KMOD], [libkmod]) PKG_CHECK_MODULES([UDEV], [libudev]) PKG_CHECK_MODULES([UUID], [uuid]) PKG_CHECK_MODULES([JSON], [json-c]) AC_ARG_WITH([bash-completion-dir], AS_HELP_STRING([--with-bash-completion-dir[=PATH]], [Install the bash auto-completion script in this directory. @<:@default=yes@:>@]), [], [with_bash_completion_dir=yes]) if test "x$with_bash_completion_dir" = "xyes"; then PKG_CHECK_MODULES([BASH_COMPLETION], [bash-completion >= 2.0], [BASH_COMPLETION_DIR="`pkg-config --variable=completionsdir bash-completion`"], [BASH_COMPLETION_DIR="$datadir/bash-completion/completions"]) else BASH_COMPLETION_DIR="$with_bash_completion_dir" fi AC_SUBST([BASH_COMPLETION_DIR]) AM_CONDITIONAL([ENABLE_BASH_COMPLETION],[test "x$with_bash_completion_dir" != "xno"]) AC_ARG_ENABLE([local], AS_HELP_STRING([--disable-local], [build against kernel ndctl.h @<:@default=system@:>@]), [], [enable_local=yes]) AC_CHECK_HEADERS_ONCE([linux/version.h]) AC_CHECK_FUNCS([ \ __secure_getenv \ secure_getenv\ ]) my_CFLAGS="\ -Wall \ -Wchar-subscripts \ -Wformat-security \ -Wmissing-declarations \ -Wmissing-prototypes \ -Wnested-externs \ -Wpointer-arith \ -Wshadow \ -Wsign-compare \ -Wstrict-prototypes \ -Wtype-limits \ -Wmaybe-uninitialized \ -Wdeclaration-after-statement \ -Wunused-result \ -D_FORTIFY_SOURCE=2 \ -O2 " AC_SUBST([my_CFLAGS]) AC_CONFIG_HEADERS(config.h) AC_CONFIG_FILES([ Makefile daxctl/lib/Makefile ndctl/lib/Makefile ndctl/Makefile daxctl/Makefile test/Makefile Documentation/ndctl/Makefile Documentation/daxctl/Makefile ]) AC_OUTPUT AC_MSG_RESULT([ $PACKAGE $VERSION ===== prefix: ${prefix} sysconfdir: ${sysconfdir} libdir: ${libdir} includedir: ${includedir} compiler: ${CC} cflags: ${CFLAGS} ldflags: ${LDFLAGS} logging: ${enable_logging} debug: ${enable_debug} ]) ndctl-61.2/contrib/000077500000000000000000000000001331777607200142235ustar00rootroot00000000000000ndctl-61.2/contrib/do_abidiff000077500000000000000000000040701331777607200162200ustar00rootroot00000000000000#!/bin/bash -e range="$*" old="${range%%..*}" new="${range##*..}" err() { echo "$1" exit 1 } build_rpm() { local cur=$(git rev-parse --abbrev-ref HEAD 2>/dev/null) local ref="$1" local version="" # prepare ndctl tree rm -rf results_ndctl git checkout -b rel_${ref} $ref ./autogen.sh ./configure CFLAGS='-g -O2' --prefix=/usr --sysconfdir=/etc --libdir=/usr/lib64 make clean make rhel/ndctl.spec cp rhel/ndctl.spec . # build and copy RPMs version="$(./git-version)" git archive --format=tar --prefix="ndctl-${version}/" HEAD | gzip > ndctl-${version}.tar.gz fedpkg --release master --module-name ndctl mockbuild mkdir -p release/rel_${ref}/ cp results_ndctl/*/*/*.x86_64.rpm release/rel_${ref}/ # restore ndctl branch and cleanup git checkout $cur git branch -D rel_${ref} rm ndctl-${version}.tar.gz rm ndctl-${version}*.src.rpm rm -rf results_ndctl rm -f ndctl.spec } do_diff() { local pkg="$1" local old_base="$(find . -regex "./release/rel_${old}/${pkg}-[0-9]+.*" | head -1)" local new_base="$(find . -regex "./release/rel_${new}/${pkg}-[0-9]+.*" | head -1)" local old_dev="$(find . -regex "./release/rel_${old}/${pkg}-devel-[0-9]+.*" | head -1)" local new_dev="$(find . -regex "./release/rel_${new}/${pkg}-devel-[0-9]+.*" | head -1)" local old_lib="$(find . -regex "./release/rel_${old}/${pkg}-libs-[0-9]+.*" | head -1)" local new_lib="$(find . -regex "./release/rel_${new}/${pkg}-libs-[0-9]+.*" | head -1)" [ -n "$pkg" ] || err "specify a package for diff (ndctl, daxctl)" abipkgdiff --dso-only --no-added-syms --harmless --drop-private-types \ --devel1 "$old_dev" --devel2 "$new_dev" \ "$old_base" "$new_base" abipkgdiff --no-added-syms --harmless --drop-private-types \ --devel1 "$old_dev" --devel2 "$new_dev" \ "$old_lib" "$new_lib" } [ -e "COPYING" ] || err "Run from the top level of an ndctl tree" if ! command -v "abipkgdiff" >/dev/null; then err "missing abipkgdiff. Please install libabigail" fi rm -rf release/rel* build_rpm $old > release/buildlog_$old 2>&1 build_rpm $new > release/buildlog_$new 2>&1 do_diff ndctl do_diff daxctl ndctl-61.2/contrib/ndctl000077500000000000000000000230761331777607200152650ustar00rootroot00000000000000# ndctl bash and zsh completion # Taken from perf's completion script. __my_reassemble_comp_words_by_ref() { local exclude i j first # Which word separators to exclude? exclude="${1//[^$COMP_WORDBREAKS]}" cword_=$COMP_CWORD if [ -z "$exclude" ]; then words_=("${COMP_WORDS[@]}") return fi # List of word completion separators has shrunk; # re-assemble words to complete. for ((i=0, j=0; i < ${#COMP_WORDS[@]}; i++, j++)); do # Append each nonempty word consisting of just # word separator characters to the current word. first=t while [ $i -gt 0 ] && [ -n "${COMP_WORDS[$i]}" ] && # word consists of excluded word separators [ "${COMP_WORDS[$i]//[^$exclude]}" = "${COMP_WORDS[$i]}" ] do # Attach to the previous token, # unless the previous token is the command name. if [ $j -ge 2 ] && [ -n "$first" ]; then ((j--)) fi first= words_[$j]=${words_[j]}${COMP_WORDS[i]} if [ $i = $COMP_CWORD ]; then cword_=$j fi if (($i < ${#COMP_WORDS[@]} - 1)); then ((i++)) else # Done. return fi done words_[$j]=${words_[j]}${COMP_WORDS[i]} if [ $i = $COMP_CWORD ]; then cword_=$j fi done } # Define preload_get_comp_words_by_ref="false", if the function # __ndctl_get_comp_words_by_ref() is required instead. preload_get_comp_words_by_ref="true" if [ $preload_get_comp_words_by_ref = "true" ]; then type _get_comp_words_by_ref &>/dev/null || preload_get_comp_words_by_ref="false" fi [ $preload_get_comp_words_by_ref = "true" ] || __ndctl_get_comp_words_by_ref() { local exclude cur_ words_ cword_ if [ "$1" = "-n" ]; then exclude=$2 shift 2 fi __my_reassemble_comp_words_by_ref "$exclude" cur_=${words_[cword_]} while [ $# -gt 0 ]; do case "$1" in cur) cur=$cur_ ;; prev) prev=${words_[$cword_-1]} ;; words) words=("${words_[@]}") ;; cword) cword=$cword_ ;; esac shift done } __ndctlcomp() { local i=0 COMPREPLY=( $( compgen -W "$1" -- "$2" ) ) for cword in "${COMPREPLY[@]}"; do if [[ "$cword" == @(--bus|--region|--type|--mode|--size|--dimm|--reconfig|--uuid|--name|--sector-size|--map|--namespace|--input|--output|--label-version|--align|--block|--count|--firmware|--media-temperature|--ctrl-temperature|--spares|--media-temperature-threshold|--ctrl-temperature-threshold|--spares-threshold|--media-temperature-alarm|--ctrl-temperature-alarm|--spares-alarm|--numa-node) ]]; then COMPREPLY[$i]="${cword}=" else COMPREPLY[$i]="${cword} " fi ((i++)) done } __ndctl_get_buses() { local opts="--buses $*" [ -n "$dimm_filter" ] && opts="$opts --dimm=$dimm_filter" [ -n "$reg_filter" ] && opts="$opts --region=$reg_filter" [ -n "$ns_filter" ] && opts="$opts --namespace=$ns_filter" echo "$(ndctl list $opts | grep -E "^\s*\"provider\":" | cut -d\" -f4)" } __ndctl_get_regions() { local opts="--regions $*" [ -n "$bus_filter" ] && opts="$opts --bus=$bus_filter" [ -n "$dimm_filter" ] && opts="$opts --dimm=$dimm_filter" [ -n "$ns_filter" ] && opts="$opts --namespace=$ns_filter" [ -n "$type_filter" ] && opts="$opts --type=$type_filter" [ -n "$idle_filter" ] && opts="$opts --idle" echo "$(ndctl list $opts | grep -E "^\s*\"dev\":" | cut -d\" -f4)" } __ndctl_get_ns() { opts="--namespaces $*" [ -n "$bus_filter" ] && opts="$opts --bus=$bus_filter" [ -n "$dimm_filter" ] && opts="$opts --dimm=$dimm_filter" [ -n "$reg_filter" ] && opts="$opts --region=$reg_filter" [ -n "$mode_filter" ] && opts="$opts --mode=$mode_filter" [ -n "$type_filter" ] && opts="$opts --type=$type_filter" [ -n "$idle_filter" ] && opts="$opts --idle" echo "$(ndctl list $opts | grep -E "^\s*\"dev\":" | cut -d\" -f4)" } __ndctl_get_dimms() { opts="--dimms $*" [ -n "$bus_filter" ] && opts="$opts --bus=$bus_filter" [ -n "$reg_filter" ] && opts="$opts --region=$reg_filter" [ -n "$ns_filter" ] && opts="$opts --namespace=$ns_filter" echo "$(ndctl list $opts | grep -E "^\s*\"dev\":" | cut -d\" -f4)" } __ndctl_get_sector_sizes() { if [[ "$mode_filter" == @(raw|memory|fsdax) ]]; then echo "512 4096" elif [[ "$mode_filter" == @(dax|devdax) ]]; then return else echo "512 520 528 4096 4104 4160 4224" fi } __ndctl_get_nodes() { local nlist="" for node in /sys/devices/system/node/node*; do node="$(basename $node)" if [[ $node =~ node([0-9]+) ]]; then nlist="$nlist ${BASH_REMATCH[1]}" else continue fi done echo "$nlist" } __ndctl_file_comp() { local cur="$1" _filedir } __ndctl_comp_options() { local cur=$1 local opts if [[ "$cur" == *=* ]]; then local cur_subopt=${cur%%=*} case $cur_subopt in --bus) opts=$(__ndctl_get_buses) ;; --region) opts=$(__ndctl_get_regions) ;; --dimm) opts=$(__ndctl_get_dimms -i) ;; --namespace) opts=$(__ndctl_get_ns) ;; --reconfig) # It is ok to reconfig disabled namespaces opts=$(__ndctl_get_ns -i) ;; --type) opts="pmem blk" if [[ "$mode_filter" == @(dax|memory|fsdax|devdax) ]]; then opts="pmem" fi ;; --mode) opts="raw sector fsdax devdax" if [[ "$type_filter" == "blk" ]]; then opts="raw sector" fi ;; --sector-size) opts=$(__ndctl_get_sector_sizes) ;; --map) opts="mem dev" ;; --output) ;& --input) ;& --firmware) __ndctl_file_comp "${cur##*=}" return ;; --label-version) opts="1.1 1.2" ;; --media-temperature-alarm) ;& --ctrl-temperature-alarm) ;& --spares-alarm) opts="on off" ;; --numa-node) opts=$(__ndctl_get_nodes) ;; *) return ;; esac __ndctlcomp "$opts" "${cur##*=}" fi } __ndctl_comp_non_option_args() { local subcmd=$1 local cur=$2 local opts case $subcmd in enable-namespace) opts="$(__ndctl_get_ns -i) all" ;; disable-namespace) ;& destroy-namespace) opts="$(__ndctl_get_ns -i) all" ;; check-namespace) opts="$(__ndctl_get_ns -i) all" ;; enable-region) opts="$(__ndctl_get_regions -i) all" ;; disable-region) opts="$(__ndctl_get_regions) all" ;; enable-dimm) opts="$(__ndctl_get_dimms -i) all" ;; disable-dimm) opts="$(__ndctl_get_dimms) all" ;; init-labels) ;& check-labels) ;& read-labels) ;& write-labels) ;& zero-labels) opts="$(__ndctl_get_dimms -i) all" ;; inject-error) opts="$(__ndctl_get_ns -i)" ;; inject-smart) opts="$(__ndctl_get_dimms -i)" ;; wait-scrub) ;& start-scrub) opts="$(__ndctl_get_buses) all" ;; *) return ;; esac __ndctlcomp "$opts" "$cur" } __ndctl_add_special_opts() { local subcmd=$1 case $subcmd in create-namespace) opts="$opts --no-autolabel" ;; esac } __ndctl_prev_skip_opts () { local i cmd_ cmds_ let i=cword-1 cmds_=$($cmd $1 --list-cmds) prev_skip_opts=() while [ $i -ge 0 ]; do if [[ ${words[i]} == $1 ]]; then return fi for cmd_ in $cmds_; do if [[ ${words[i]} == $cmd_ ]]; then prev_skip_opts=${words[i]} return fi done ((i--)) done } __ndctl_init_filters() { bus_filter='' reg_filter='' ns_filter='' dimm_filter='' type_filter='' idle_filter='' mode_filter='' for __word in "${words[@]}"; do if [[ "$__word" =~ --bus=(.*) ]]; then bus_filter="${BASH_REMATCH[1]}" # lets make sure this is in the list of buses local buses=$(__ndctl_get_buses) [[ "$buses" == *"$bus_filter"* ]] || bus_filter='' fi if [[ "$__word" =~ --region=(.*) ]]; then reg_filter="${BASH_REMATCH[1]}" # lets make sure this is in the list of regions local regions=$(__ndctl_get_regions -i) [[ "$regions" == *"$reg_filter"* ]] || reg_filter='' fi if [[ "$__word" =~ --namespace=(.*) ]]; then ns_filter="${BASH_REMATCH[1]}" # lets make sure this is in the list of namespaces local nss=$(__ndctl_get_ns -i) [[ "$nss" == *"$ns_filter"* ]] || ns_filter='' fi if [[ "$__word" =~ --dimm=(.*) ]]; then dimm_filter="${BASH_REMATCH[1]}" # lets make sure this is in the list of dimms local dimms=$(__ndctl_get_dimms) [[ "$dimms" == *"$dimm_filter"* ]] || dimm_filter='' fi if [[ "$__word" =~ --idle ]]; then idle_filter="1" fi if [[ "$__word" =~ --type=(.*) ]]; then type_filter="${BASH_REMATCH[1]}" fi if [[ "$__word" =~ --mode=(.*) ]]; then mode_filter="${BASH_REMATCH[1]}" fi done } __ndctl_main() { local cmd subcmd cmd=${words[0]} COMPREPLY=() __ndctl_init_filters # Skip options backward and find the last ndctl command __ndctl_prev_skip_opts subcmd=$prev_skip_opts # List ndctl subcommands or long options if [ -z $subcmd ]; then if [[ $cur == --* ]]; then cmds="--version --help --list-cmds" else cmds=$($cmd --list-cmds) fi __ndctlcomp "$cmds" "$cur" else # List long option names if [[ $cur == --* ]]; then opts=$($cmd $subcmd --list-opts) __ndctl_add_special_opts "$subcmd" __ndctlcomp "$opts" "$cur" __ndctl_comp_options "$cur" else [ -z "$subcmd" ] && return __ndctl_comp_non_option_args "$subcmd" "$cur" fi fi } if [[ -n ${ZSH_VERSION-} ]]; then autoload -U +X compinit && compinit __ndctlcomp() { emulate -L zsh local c IFS=$' \t\n' local -a array for c in ${=1}; do case $c in --*=*|*.) ;; *) c="$c " ;; esac array[${#array[@]}+1]="$c" done compset -P '*[=:]' compadd -Q -S '' -a -- array && _ret=0 } _ndctl() { local _ret=1 cur cword prev cur=${words[CURRENT]} prev=${words[CURRENT-1]} let cword=CURRENT-1 emulate ksh -c __ndctl_main let _ret && _default && _ret=0 return _ret } compdef _ndctl ndctl return fi type ndctl &>/dev/null && _ndctl() { local cur words cword prev if [ $preload_get_comp_words_by_ref = "true" ]; then _get_comp_words_by_ref -n =: cur words cword prev else __ndctl_get_comp_words_by_ref -n =: cur words cword prev fi __ndctl_main } && complete -o nospace -F _ndctl ndctl 2>/dev/null ndctl-61.2/contrib/prepare-release.sh000077500000000000000000000131501331777607200176360ustar00rootroot00000000000000#!/bin/bash -e # Arguments: # fix - fixup release instead of a full release # ignore_rev - ignore the check for _REVISION in libtool versioning checks # Notes: # - Checkout to the appropriate branch beforehand # master - for major release # ndctl-xx.y - for fixup release # This is important for generating the shortlog # - Add a temporary commit that updates the libtool versions as needed. # This will later become the release commit. Use --amend to add in the # git-version update and the message body. # Pre-reqs: # - libabigail (for abipkgdiff) # - fedpkg (for mock build) # TODO # - auto generate a release commit/tag message template # - determine the most recent kernel release and add it to the above # - perform documentation update for pmem.io/ndctl cleanup() { rm -rf release mkdir release/ } err() { echo "$1" exit 1 } parse_args() { local args="$*" grep -q "fix" <<< "$args" && rel_fix="1" || rel_fix="" grep -q "ignore_rev" <<< "$args" && ignore_rev="1" || ignore_rev="" } check_branch() { local cur=$(git rev-parse --abbrev-ref HEAD 2>/dev/null) if [ -n "$rel_fix" ]; then # fixup release, expect ndctl-xx.y branch if ! grep -Eq "^ndctl.[0-9]+\.y$" <<< "$cur"; then err "expected an ndctl-xx.y branch for fixup release" fi else # major release, expect master branch if ! grep -Eq "^master$" <<< "$cur"; then err "expected master branch for a major release" fi fi if ! git diff-index --quiet HEAD --; then err "$cur has uncommitted/unstaged changes" fi } last_maj() { git tag | sort -V | grep -E "v[0-9]+$" | tail -1 } last_fix() { local base="$1" git tag | sort -V | grep -E "$base\.?[0-9]*$" | tail -1 } next_maj() { local last="$1" local num=${last#v} newnum="$((num + 1))" echo "v$newnum" } next_fix() { local last="$1" local num=${last##*.} local base=${last%%.*} newnum=$((num + 1)) echo "$base.$newnum" } gen_lists() { local range="$1" git shortlog "$range" > release/shortlog git log --pretty=format:"%s" "$range" > release/commits c_count=$(git log --pretty=format:"%s" "$range" | wc -l) } # Check libtool versions in Makefile.am.in # $1: lib name (currently libndctl or libdaxctl) check_libtool_vers() { local lib="$1" local lib_u="${lib^^}" local libdir="${lib##lib}" local symfile="${libdir}/lib/${lib}.sym" local last_cur=$(git show $last_ref:Makefile.am.in | grep -E "^${lib_u}_CURRENT" | cut -d'=' -f2) local last_rev=$(git show $last_ref:Makefile.am.in | grep -E "^${lib_u}_REVISION" | cut -d'=' -f2) local last_age=$(git show $last_ref:Makefile.am.in | grep -E "^${lib_u}_AGE" | cut -d'=' -f2) local last_soname=$((last_cur - last_age)) local next_cur=$(git show HEAD:Makefile.am.in | grep -E "^${lib_u}_CURRENT" | cut -d'=' -f2) local next_rev=$(git show HEAD:Makefile.am.in | grep -E "^${lib_u}_REVISION" | cut -d'=' -f2) local next_age=$(git show HEAD:Makefile.am.in | grep -E "^${lib_u}_AGE" | cut -d'=' -f2) local next_soname=$((next_cur - next_age)) local soname_diff=$((next_soname - last_soname)) # generally libtool versions either reset to zero or increase only by one # _CURRENT monotonically increases (by one) if [ "$((next_cur - last_cur))" -gt 1 ]; then err "${lib_u}_CURRENT can increase at most by 1" fi if [ "$next_rev" -ne 0 ]; then if [ "$((next_rev - last_rev))" -gt 1 ]; then err "${lib_u}_REVISION can increase at most by 1" fi fi if [ "$next_age" -ne 0 ]; then if [ "$((next_age - last_age))" -gt 1 ]; then err "${lib_u}_AGE can increase at most by 1" fi fi # test for soname change if [ "$soname_diff" -ne 0 ]; then err "${lib}: expected soname to stay unchanged" fi # tests based on whether symfile changed # compatibility breaking changes are left for libabigail to detect test -s "$symfile" || err "$symfile: not found" if [ -n "$(git diff --name-only $last_ref..HEAD $symfile)" ]; then # symfile has changed, cur and age should increase if [ "$((next_cur - last_cur))" -ne 1 ]; then err "based on $symfile, ${lib_u}_CURRENT should've increased by 1" fi if [ "$((next_age - last_age))" -ne 1 ]; then err "based on $symfile, ${lib_u}_AGE should've increased by 1" fi else # no changes to symfile, revision should've increased if source changed if [ -n "$ignore_rev" ]; then : # skip elif [ -n "$(git diff --name-only $last_ref..HEAD $libdir/)" ]; then if [ "$((next_rev - last_rev))" -ne 1 ]; then err "based on $symfile, ${lib_u}_REVISION should've increased by 1" fi fi fi } # main cleanup parse_args "$*" check_branch [ -e "COPYING" ] || err "Run from the top level of an ndctl tree" last_maj=$(last_maj) test -n "$last_maj" || err "Unable to determine last release" last_fix=$(last_fix $last_maj) test -n "$last_fix" || err "Unable to determine last fixup tag for $last_maj" next_maj=$(next_maj "$last_maj") next_fix=$(next_fix "$last_fix") [ -n "$rel_fix" ] && last_ref="$last_fix" || last_ref="$last_maj" [ -n "$rel_fix" ] && next_ref="$next_fix" || next_ref="$next_maj" check_libtool_vers "libndctl" check_libtool_vers "libdaxctl" gen_lists ${last_ref}..HEAD # For ABI diff purposes, use the latest fixes tag contrib/do_abidiff ${last_fix}..HEAD # once everything passes, update the git-version sed -i -e "s/DEF_VER=[0-9]\+.*/DEF_VER=${next_ref#v}/" git-version echo "Ready to release ndctl-$next_ref with $c_count new commits." echo "Add git-version to the top commit to get the updated version." echo "Use release/commits and release/shortlog to compose the release message" echo "The release commit typically contains the Makefile.am.in libtool version" echo "update, and the git-version update." echo "Finally, ensure the release commit as well as the tag are PGP signed." ndctl-61.2/daxctl/000077500000000000000000000000001331777607200140425ustar00rootroot00000000000000ndctl-61.2/daxctl/Makefile.am000066400000000000000000000003131331777607200160730ustar00rootroot00000000000000include $(top_srcdir)/Makefile.am.in bin_PROGRAMS = daxctl daxctl_SOURCES =\ daxctl.c \ list.c \ ../util/json.c daxctl_LDADD =\ lib/libdaxctl.la \ ../libutil.a \ $(UUID_LIBS) \ $(JSON_LIBS) ndctl-61.2/daxctl/daxctl.c000066400000000000000000000053101331777607200154640ustar00rootroot00000000000000/* * Copyright(c) 2015-2017 Intel Corporation. All rights reserved. * Copyright(c) 2005 Andreas Ericsson. All rights reserved. * * This program is free software; you can redistribute it and/or modify it * under the terms of version 2 of the GNU General Public License as * published by the Free Software Foundation. * * 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 * General Public License for more details. */ /* originally copied from perf and git */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include const char daxctl_usage_string[] = "daxctl [--version] [--help] COMMAND [ARGS]"; const char daxctl_more_info_string[] = "See 'daxctl help COMMAND' for more information on a specific command.\n" " daxctl --list-cmds to see all available commands"; static int cmd_version(int argc, const char **argv, void *ctx) { printf("%s\n", VERSION); return 0; } static int cmd_help(int argc, const char **argv, void *ctx) { const char * const builtin_help_subcommands[] = { "list", NULL, }; struct option builtin_help_options[] = { OPT_END(), }; const char *builtin_help_usage[] = { "daxctl help [command]", NULL }; argc = parse_options_subcommand(argc, argv, builtin_help_options, builtin_help_subcommands, builtin_help_usage, 0); if (!argv[0]) { printf("\n usage: %s\n\n", daxctl_usage_string); printf("\n %s\n\n", daxctl_more_info_string); return 0; } return help_show_man_page(argv[0], "daxctl", "DAXCTL_MAN_VIEWER"); } int cmd_list(int argc, const char **argv, void *ctx); static struct cmd_struct commands[] = { { "version", cmd_version }, { "list", cmd_list }, { "help", cmd_help }, }; int main(int argc, const char **argv) { struct daxctl_ctx *ctx; int rc; /* Look for flags.. */ argv++; argc--; main_handle_options(&argv, &argc, daxctl_usage_string, commands, ARRAY_SIZE(commands)); if (argc > 0) { if (!prefixcmp(argv[0], "--")) argv[0] += 2; } else { /* The user didn't specify a command; give them help */ printf("\n usage: %s\n\n", daxctl_usage_string); printf("\n %s\n\n", daxctl_more_info_string); goto out; } rc = daxctl_new(&ctx); if (rc) goto out; main_handle_internal_command(argc, argv, ctx, commands, ARRAY_SIZE(commands)); daxctl_unref(ctx); fprintf(stderr, "Unknown command: '%s'\n", argv[0]); out: return 1; } ndctl-61.2/daxctl/lib/000077500000000000000000000000001331777607200146105ustar00rootroot00000000000000ndctl-61.2/daxctl/lib/Makefile.am000066400000000000000000000013161331777607200166450ustar00rootroot00000000000000include $(top_srcdir)/Makefile.am.in %.pc: %.pc.in Makefile $(SED_PROCESS) pkginclude_HEADERS = ../libdaxctl.h lib_LTLIBRARIES = libdaxctl.la libdaxctl_la_SOURCES =\ ../libdaxctl.h \ libdaxctl-private.h \ ../../util/sysfs.c \ ../../util/sysfs.h \ ../../util/log.c \ ../../util/log.h \ libdaxctl.c libdaxctl_la_LIBADD =\ $(UUID_LIBS) EXTRA_DIST += libdaxctl.sym libdaxctl_la_LDFLAGS = $(AM_LDFLAGS) \ -version-info $(LIBDAXCTL_CURRENT):$(LIBDAXCTL_REVISION):$(LIBDAXCTL_AGE) \ -Wl,--version-script=$(top_srcdir)/daxctl/lib/libdaxctl.sym libdaxctl_la_DEPENDENCIES = libdaxctl.sym pkgconfigdir = $(libdir)/pkgconfig pkgconfig_DATA = libdaxctl.pc EXTRA_DIST += libdaxctl.pc.in CLEANFILES += libdaxctl.pc ndctl-61.2/daxctl/lib/libdaxctl-private.h000066400000000000000000000023101331777607200203730ustar00rootroot00000000000000/* * Copyright (c) 2014-2016, Intel Corporation. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU Lesser General Public License, * version 2.1, as published by the Free Software Foundation. * * This program is distributed in the hope 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. */ #ifndef _LIBDAXCTL_PRIVATE_H_ #define _LIBDAXCTL_PRIVATE_H_ #define DAXCTL_EXPORT __attribute__ ((visibility("default"))) /** * struct daxctl_region - container for dax_devices */ #define REGION_BUF_SIZE 50 struct daxctl_region { int id; uuid_t uuid; int refcount; char *devname; size_t buf_len; void *region_buf; int devices_init; char *region_path; unsigned long align; unsigned long long size; struct daxctl_ctx *ctx; struct list_node list; struct list_head devices; }; struct daxctl_dev { int id, major, minor; void *dev_buf; size_t buf_len; char *dev_path; struct list_node list; unsigned long long size; struct daxctl_region *region; }; #endif /* _LIBDAXCTL_PRIVATE_H_ */ ndctl-61.2/daxctl/lib/libdaxctl.c000066400000000000000000000330331331777607200167240ustar00rootroot00000000000000/* * Copyright (c) 2016, Intel Corporation. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU Lesser General Public License, * version 2.1, as published by the Free Software Foundation. * * This program is distributed in the hope 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. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "libdaxctl-private.h" static const char *attrs = "dax_region"; static void free_region(struct daxctl_region *region, struct list_head *head); /** * struct daxctl_ctx - library user context to find "nd" instances * * Instantiate with daxctl_new(), which takes an initial reference. Free * the context by dropping the reference count to zero with * daxctl_unref(), or take additional references with daxctl_ref() * @timeout: default library timeout in milliseconds */ struct daxctl_ctx { /* log_ctx must be first member for daxctl_set_log_fn compat */ struct log_ctx ctx; int refcount; void *userdata; int regions_init; struct list_head regions; }; /** * daxctl_get_userdata - retrieve stored data pointer from library context * @ctx: daxctl library context * * This might be useful to access from callbacks like a custom logging * function. */ DAXCTL_EXPORT void *daxctl_get_userdata(struct daxctl_ctx *ctx) { if (ctx == NULL) return NULL; return ctx->userdata; } /** * daxctl_set_userdata - store custom @userdata in the library context * @ctx: daxctl library context * @userdata: data pointer */ DAXCTL_EXPORT void daxctl_set_userdata(struct daxctl_ctx *ctx, void *userdata) { if (ctx == NULL) return; ctx->userdata = userdata; } /** * daxctl_new - instantiate a new library context * @ctx: context to establish * * Returns zero on success and stores an opaque pointer in ctx. The * context is freed by daxctl_unref(), i.e. daxctl_new() implies an * internal daxctl_ref(). */ DAXCTL_EXPORT int daxctl_new(struct daxctl_ctx **ctx) { struct daxctl_ctx *c; c = calloc(1, sizeof(struct daxctl_ctx)); if (!c) return -ENOMEM; c->refcount = 1; log_init(&c->ctx, "libdaxctl", "DAXCTL_LOG"); info(c, "ctx %p created\n", c); dbg(c, "log_priority=%d\n", c->ctx.log_priority); *ctx = c; list_head_init(&c->regions); return 0; } /** * daxctl_ref - take an additional reference on the context * @ctx: context established by daxctl_new() */ DAXCTL_EXPORT struct daxctl_ctx *daxctl_ref(struct daxctl_ctx *ctx) { if (ctx == NULL) return NULL; ctx->refcount++; return ctx; } /** * daxctl_unref - drop a context reference count * @ctx: context established by daxctl_new() * * Drop a reference and if the resulting reference count is 0 destroy * the context. */ DAXCTL_EXPORT void daxctl_unref(struct daxctl_ctx *ctx) { struct daxctl_region *region, *_r; if (ctx == NULL) return; ctx->refcount--; if (ctx->refcount > 0) return; list_for_each_safe(&ctx->regions, region, _r, list) free_region(region, &ctx->regions); info(ctx, "context %p released\n", ctx); free(ctx); } /** * daxctl_set_log_fn - override default log routine * @ctx: daxctl library context * @log_fn: function to be called for logging messages * * The built-in logging writes to stderr. It can be overridden by a * custom function, to plug log messages into the user's logging * functionality. */ DAXCTL_EXPORT void daxctl_set_log_fn(struct daxctl_ctx *ctx, void (*daxctl_log_fn)(struct daxctl_ctx *ctx, int priority, const char *file, int line, const char *fn, const char *format, va_list args)) { ctx->ctx.log_fn = (log_fn) daxctl_log_fn; info(ctx, "custom logging function %p registered\n", daxctl_log_fn); } /** * daxctl_get_log_priority - retrieve current library loglevel (syslog) * @ctx: daxctl library context */ DAXCTL_EXPORT int daxctl_get_log_priority(struct daxctl_ctx *ctx) { return ctx->ctx.log_priority; } /** * daxctl_set_log_priority - set log verbosity * @priority: from syslog.h, LOG_ERR, LOG_INFO, LOG_DEBUG * * Note: LOG_DEBUG requires library be built with "configure --enable-debug" */ DAXCTL_EXPORT void daxctl_set_log_priority(struct daxctl_ctx *ctx, int priority) { ctx->ctx.log_priority = priority; } DAXCTL_EXPORT struct daxctl_ctx *daxctl_region_get_ctx( struct daxctl_region *region) { return region->ctx; } DAXCTL_EXPORT void daxctl_region_get_uuid(struct daxctl_region *region, uuid_t uu) { uuid_copy(uu, region->uuid); } static void free_dev(struct daxctl_dev *dev, struct list_head *head) { if (head) list_del_from(head, &dev->list); free(dev->dev_buf); free(dev->dev_path); free(dev); } static void free_region(struct daxctl_region *region, struct list_head *head) { struct daxctl_dev *dev, *_d; list_for_each_safe(®ion->devices, dev, _d, list) free_dev(dev, ®ion->devices); if (head) list_del_from(head, ®ion->list); free(region->region_path); free(region->region_buf); free(region->devname); free(region); } DAXCTL_EXPORT void daxctl_region_unref(struct daxctl_region *region) { struct daxctl_ctx *ctx; if (!region) return; region->refcount--; if (region->refcount) return; ctx = region->ctx; dbg(ctx, "%s: %s\n", __func__, daxctl_region_get_devname(region)); free_region(region, &ctx->regions); } DAXCTL_EXPORT void daxctl_region_ref(struct daxctl_region *region) { if (region) region->refcount++; } static struct daxctl_region *add_dax_region(void *parent, int id, const char *base) { struct daxctl_region *region, *region_dup; struct daxctl_ctx *ctx = parent; char buf[SYSFS_ATTR_SIZE]; char *path; dbg(ctx, "%s: \'%s\'\n", __func__, base); daxctl_region_foreach(ctx, region_dup) if (strcmp(region_dup->region_path, base) == 0) return region_dup; path = calloc(1, strlen(base) + 100); if (!path) return NULL; region = calloc(1, sizeof(*region)); if (!region) goto err_region; region->id = id; region->align = -1; region->size = -1; region->ctx = ctx; region->refcount = 1; list_head_init(®ion->devices); region->devname = strdup(devpath_to_devname(base)); sprintf(path, "%s/%s/size", base, attrs); if (sysfs_read_attr(ctx, path, buf) == 0) region->size = strtoull(buf, NULL, 0); sprintf(path, "%s/%s/align", base, attrs); if (sysfs_read_attr(ctx, path, buf) == 0) region->align = strtoul(buf, NULL, 0); region->region_path = strdup(base); if (!region->region_path) goto err_read; region->region_buf = calloc(1, strlen(path) + strlen(attrs) + REGION_BUF_SIZE); if (!region->region_buf) goto err_read; region->buf_len = strlen(path) + REGION_BUF_SIZE; list_add(&ctx->regions, ®ion->list); free(path); return region; err_read: free(region->region_buf); free(region->region_path); free(region); err_region: free(path); return NULL; } DAXCTL_EXPORT struct daxctl_region *daxctl_new_region(struct daxctl_ctx *ctx, int id, uuid_t uuid, const char *path) { struct daxctl_region *region; region = add_dax_region(ctx, id, path); if (!region) return NULL; uuid_copy(region->uuid, uuid); dbg(ctx, "%s: %s\n", __func__, daxctl_region_get_devname(region)); return region; } static void *add_dax_dev(void *parent, int id, const char *daxdev_base) { const char *devname = devpath_to_devname(daxdev_base); char *path = calloc(1, strlen(daxdev_base) + 100); struct daxctl_region *region = parent; struct daxctl_ctx *ctx = region->ctx; struct daxctl_dev *dev, *dev_dup; char buf[SYSFS_ATTR_SIZE]; struct stat st; if (!path) return NULL; dbg(ctx, "%s: base: \'%s\'\n", __func__, daxdev_base); dev = calloc(1, sizeof(*dev)); if (!dev) goto err_dev; dev->id = id; dev->region = region; sprintf(path, "/dev/%s", devname); if (stat(path, &st) < 0) goto err_read; dev->major = major(st.st_rdev); dev->minor = minor(st.st_rdev); sprintf(path, "%s/size", daxdev_base); if (sysfs_read_attr(ctx, path, buf) < 0) goto err_read; dev->size = strtoull(buf, NULL, 0); dev->dev_path = strdup(daxdev_base); if (!dev->dev_path) goto err_read; dev->dev_buf = calloc(1, strlen(daxdev_base) + 50); if (!dev->dev_buf) goto err_read; dev->buf_len = strlen(daxdev_base) + 50; daxctl_dev_foreach(region, dev_dup) if (dev_dup->id == dev->id) { free_dev(dev, NULL); free(path); return dev_dup; } list_add(®ion->devices, &dev->list); free(path); return dev; err_read: free(dev->dev_buf); free(dev->dev_path); free(dev); err_dev: free(path); return NULL; } DAXCTL_EXPORT int daxctl_region_get_id(struct daxctl_region *region) { return region->id; } DAXCTL_EXPORT unsigned long daxctl_region_get_align(struct daxctl_region *region) { return region->align; } DAXCTL_EXPORT unsigned long long daxctl_region_get_size(struct daxctl_region *region) { return region->size; } DAXCTL_EXPORT const char *daxctl_region_get_devname(struct daxctl_region *region) { return region->devname; } DAXCTL_EXPORT const char *daxctl_region_get_path(struct daxctl_region *region) { return region->region_path; } DAXCTL_EXPORT unsigned long long daxctl_region_get_available_size( struct daxctl_region *region) { struct daxctl_ctx *ctx = daxctl_region_get_ctx(region); char *path = region->region_buf; char buf[SYSFS_ATTR_SIZE], *end; int len = region->buf_len; unsigned long long avail; if (snprintf(path, len, "%s/%s/available_size", region->region_path, attrs) >= len) { err(ctx, "%s: buffer too small!\n", daxctl_region_get_devname(region)); return 0; } if (sysfs_read_attr(ctx, path, buf) < 0) return 0; avail = strtoull(buf, &end, 0); if (buf[0] && *end == '\0') return avail; return 0; } DAXCTL_EXPORT struct daxctl_dev *daxctl_region_get_dev_seed( struct daxctl_region *region) { struct daxctl_ctx *ctx = daxctl_region_get_ctx(region); char *path = region->region_buf; int len = region->buf_len; char buf[SYSFS_ATTR_SIZE]; struct daxctl_dev *dev; if (snprintf(path, len, "%s/%s/seed", region->region_path, attrs) >= len) { err(ctx, "%s: buffer too small!\n", daxctl_region_get_devname(region)); return NULL; } if (sysfs_read_attr(ctx, path, buf) < 0) return NULL; daxctl_dev_foreach(region, dev) if (strcmp(buf, daxctl_dev_get_devname(dev)) == 0) return dev; return NULL; } static void dax_devices_init(struct daxctl_region *region) { struct daxctl_ctx *ctx = daxctl_region_get_ctx(region); char daxdev_fmt[50]; char *region_path; if (region->devices_init) return; region->devices_init = 1; sprintf(daxdev_fmt, "dax%d.", region->id); if (asprintf(®ion_path, "%s/dax", region->region_path) < 0) { dbg(ctx, "region path alloc fail\n"); return; } sysfs_device_parse(ctx, region_path, daxdev_fmt, region, add_dax_dev); free(region_path); } static char *dax_region_path(const char *base, const char *device) { char *path, *region_path, *c; if (asprintf(&path, "%s/%s", base, device) < 0) return NULL; /* dax_region must be the instance's direct parent */ region_path = realpath(path, NULL); free(path); if (!region_path) return NULL; /* 'region_path' is now regionX/dax/daxX.Y', trim back to regionX */ c = strrchr(region_path, '/'); if (!c) { free(region_path); return NULL; } *c = '\0'; c = strrchr(region_path, '/'); if (!c) { free(region_path); return NULL; } *c = '\0'; return region_path; } static void dax_regions_init(struct daxctl_ctx *ctx) { const char *base = "/sys/class/dax"; struct dirent *de; DIR *dir; if (ctx->regions_init) return; ctx->regions_init = 1; dir = opendir(base); if (!dir) { dbg(ctx, "no dax regions found\n"); return; } while ((de = readdir(dir)) != NULL) { struct daxctl_region *region; int id, region_id; char *dev_path; if (de->d_ino == 0) continue; if (sscanf(de->d_name, "dax%d.%d", ®ion_id, &id) != 2) continue; dev_path = dax_region_path(base, de->d_name); if (!dev_path) { err(ctx, "dax region path allocation failure\n"); continue; } region = add_dax_region(ctx, region_id, dev_path); free(dev_path); if (!region) err(ctx, "add_dax_region() for %s failed\n", de->d_name); } closedir(dir); } DAXCTL_EXPORT struct daxctl_dev *daxctl_dev_get_first(struct daxctl_region *region) { dax_devices_init(region); return list_top(®ion->devices, struct daxctl_dev, list); } DAXCTL_EXPORT struct daxctl_dev *daxctl_dev_get_next(struct daxctl_dev *dev) { struct daxctl_region *region = dev->region; return list_next(®ion->devices, dev, list); } DAXCTL_EXPORT struct daxctl_region *daxctl_region_get_first( struct daxctl_ctx *ctx) { dax_regions_init(ctx); return list_top(&ctx->regions, struct daxctl_region, list); } DAXCTL_EXPORT struct daxctl_region *daxctl_region_get_next( struct daxctl_region *region) { struct daxctl_ctx *ctx = region->ctx; return list_next(&ctx->regions, region, list); } DAXCTL_EXPORT struct daxctl_region *daxctl_dev_get_region(struct daxctl_dev *dev) { return dev->region; } DAXCTL_EXPORT int daxctl_dev_get_id(struct daxctl_dev *dev) { return dev->id; } DAXCTL_EXPORT const char *daxctl_dev_get_devname(struct daxctl_dev *dev) { return devpath_to_devname(dev->dev_path); } DAXCTL_EXPORT int daxctl_dev_get_major(struct daxctl_dev *dev) { return dev->major; } DAXCTL_EXPORT int daxctl_dev_get_minor(struct daxctl_dev *dev) { return dev->minor; } DAXCTL_EXPORT unsigned long long daxctl_dev_get_size(struct daxctl_dev *dev) { return dev->size; } ndctl-61.2/daxctl/lib/libdaxctl.pc.in000066400000000000000000000003401331777607200175040ustar00rootroot00000000000000prefix=@prefix@ exec_prefix=@exec_prefix@ libdir=@libdir@ includedir=@includedir@ Name: libdaxctl Description: Manage "Device DAX" devices Version: @VERSION@ Libs: -L${libdir} -ldaxctl Libs.private: Cflags: -I${includedir} ndctl-61.2/daxctl/lib/libdaxctl.sym000066400000000000000000000016151331777607200173130ustar00rootroot00000000000000LIBDAXCTL_1 { global: daxctl_get_userdata; daxctl_set_userdata; daxctl_ref; daxctl_get_log_priority; daxctl_set_log_fn; daxctl_unref; daxctl_set_log_priority; daxctl_new; local: *; }; LIBDAXCTL_2 { global: daxctl_region_unref; daxctl_new_region; daxctl_region_ref; daxctl_region_unref; daxctl_region_get_uuid; daxctl_region_get_id; daxctl_region_get_ctx; daxctl_dev_get_first; daxctl_dev_get_next; daxctl_dev_get_region; daxctl_dev_get_id; daxctl_dev_get_devname; daxctl_dev_get_major; daxctl_dev_get_minor; daxctl_dev_get_size; } LIBDAXCTL_1; LIBDAXCTL_3 { global: daxctl_region_get_available_size; daxctl_region_get_devname; daxctl_region_get_dev_seed; } LIBDAXCTL_2; LIBDAXCTL_4 { global: daxctl_region_get_size; daxctl_region_get_align; daxctl_region_get_first; daxctl_region_get_next; } LIBDAXCTL_3; LIBDAXCTL_5 { global: daxctl_region_get_path; } LIBDAXCTL_4; ndctl-61.2/daxctl/libdaxctl.h000066400000000000000000000062541331777607200161700ustar00rootroot00000000000000/* * Copyright (c) 2016, Intel Corporation. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU Lesser General Public License, * version 2.1, as published by the Free Software Foundation. * * This program is distributed in the hope 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. */ #ifndef _LIBDAXCTL_H_ #define _LIBDAXCTL_H_ #include #include #ifdef HAVE_LIBUUID #include #else typedef unsigned char uuid_t[16]; #endif #ifdef __cplusplus extern "C" { #endif struct daxctl_ctx; struct daxctl_ctx *daxctl_ref(struct daxctl_ctx *ctx); void daxctl_unref(struct daxctl_ctx *ctx); int daxctl_new(struct daxctl_ctx **ctx); void daxctl_set_log_fn(struct daxctl_ctx *ctx, void (*log_fn)(struct daxctl_ctx *ctx, int priority, const char *file, int line, const char *fn, const char *format, va_list args)); int daxctl_get_log_priority(struct daxctl_ctx *ctx); void daxctl_set_log_priority(struct daxctl_ctx *ctx, int priority); void daxctl_set_userdata(struct daxctl_ctx *ctx, void *userdata); void *daxctl_get_userdata(struct daxctl_ctx *ctx); struct daxctl_region; struct daxctl_region *daxctl_new_region(struct daxctl_ctx *ctx, int id, uuid_t uuid, const char *path); struct daxctl_region *daxctl_region_get_first(struct daxctl_ctx *ctx); struct daxctl_region *daxctl_region_get_next(struct daxctl_region *region); void daxctl_region_ref(struct daxctl_region *region); void daxctl_region_unref(struct daxctl_region *region); void daxctl_region_get_uuid(struct daxctl_region *region, uuid_t uu); int daxctl_region_get_id(struct daxctl_region *region); struct daxctl_ctx *daxctl_region_get_ctx(struct daxctl_region *region); unsigned long long daxctl_region_get_available_size( struct daxctl_region *region); unsigned long long daxctl_region_get_size(struct daxctl_region *region); unsigned long daxctl_region_get_align(struct daxctl_region *region); const char *daxctl_region_get_devname(struct daxctl_region *region); const char *daxctl_region_get_path(struct daxctl_region *region); struct daxctl_dev *daxctl_region_get_dev_seed(struct daxctl_region *region); struct daxctl_dev; struct daxctl_dev *daxctl_dev_get_first(struct daxctl_region *region); struct daxctl_dev *daxctl_dev_get_next(struct daxctl_dev *dev); struct daxctl_region *daxctl_dev_get_region(struct daxctl_dev *dev); int daxctl_dev_get_id(struct daxctl_dev *dev); const char *daxctl_dev_get_devname(struct daxctl_dev *dev); int daxctl_dev_get_major(struct daxctl_dev *dev); int daxctl_dev_get_minor(struct daxctl_dev *dev); unsigned long long daxctl_dev_get_size(struct daxctl_dev *dev); #define daxctl_dev_foreach(region, dev) \ for (dev = daxctl_dev_get_first(region); \ dev != NULL; \ dev = daxctl_dev_get_next(dev)) #define daxctl_region_foreach(ctx, region) \ for (region = daxctl_region_get_first(ctx); \ region != NULL; \ region = daxctl_region_get_next(region)) #ifdef __cplusplus } /* extern "C" */ #endif #endif ndctl-61.2/daxctl/list.c000066400000000000000000000064131331777607200151650ustar00rootroot00000000000000/* * Copyright(c) 2015-2017 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify it * under the terms of version 2 of the GNU General Public License as * published by the Free Software Foundation. * * 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 * General Public License for more details. */ #include #include #include #include #include #include #include #include #include #include #include static struct { bool devs; bool regions; bool idle; bool human; } list; static unsigned long listopts_to_flags(void) { unsigned long flags = 0; if (list.devs) flags |= UTIL_JSON_DAX_DEVS; if (list.idle) flags |= UTIL_JSON_IDLE; if (list.human) flags |= UTIL_JSON_HUMAN; return flags; } static struct { const char *dev; int region_id; } param = { .region_id = -1, }; static int did_fail; static int jflag = JSON_C_TO_STRING_PRETTY; #define fail(fmt, ...) \ do { \ did_fail = 1; \ fprintf(stderr, "daxctl-%s:%s:%d: " fmt, \ VERSION, __func__, __LINE__, ##__VA_ARGS__); \ } while (0) static int num_list_flags(void) { return list.regions + list.devs; } int cmd_list(int argc, const char **argv, void *ctx) { const struct option options[] = { OPT_INTEGER('r', "region", ¶m.region_id, "filter by region"), OPT_STRING('d', "dev", ¶m.dev, "dev-id", "filter by dax device instance name"), OPT_BOOLEAN('D', "devices", &list.devs, "include dax device info"), OPT_BOOLEAN('R', "regions", &list.regions, "include dax region info"), OPT_BOOLEAN('i', "idle", &list.idle, "include idle devices"), OPT_BOOLEAN('u', "human", &list.human, "use human friendly number formats "), OPT_END(), }; const char * const u[] = { "daxctl list []", NULL }; struct json_object *jregions = NULL; struct json_object *jdevs = NULL; struct daxctl_region *region; int i; argc = parse_options(argc, argv, options, u, 0); for (i = 0; i < argc; i++) error("unknown parameter \"%s\"\n", argv[i]); if (argc) usage_with_options(u, options); if (num_list_flags() == 0) { list.regions = param.region_id >= 0; list.devs = !!param.dev; } if (num_list_flags() == 0) list.devs = true; daxctl_region_foreach(ctx, region) { struct json_object *jregion = NULL; if (param.region_id >= 0 && param.region_id != daxctl_region_get_id(region)) continue; if (list.regions) { if (!jregions) { jregions = json_object_new_array(); if (!jregions) { fail("\n"); continue; } } jregion = util_daxctl_region_to_json(region, param.dev, listopts_to_flags()); if (!jregion) { fail("\n"); continue; } json_object_array_add(jregions, jregion); } else if (list.devs) jdevs = util_daxctl_devs_to_list(region, jdevs, param.dev, listopts_to_flags()); } if (jregions) util_display_json_array(stdout, jregions, jflag); else if (jdevs) util_display_json_array(stdout, jdevs, jflag); if (did_fail) return -ENOMEM; return 0; } ndctl-61.2/git-version000077500000000000000000000016511331777607200147620ustar00rootroot00000000000000#!/bin/bash to_ver() { VN=$1 #drop leading 'v' out of the version so its a pure number if [ ${VN:0:1} = "v" ]; then VN=${VN:1} fi echo $VN } dirty() { VN=$(to_ver $1) git update-index -q --refresh if test -z "$(git diff-index --name-only HEAD --)"; then echo "$VN" else echo "${VN}.dirty" fi } DEF_VER=61.2 LF=' ' # First see if there is a version file (included in release tarballs), # then try git-describe, then default. if test -f version; then VN=$(cat version) || VN="$DEF_VER" elif test -d ${GIT_DIR:-.git} -o -f .git && VN=$(git describe --match "v[0-9]*" --abbrev=7 HEAD 2>/dev/null) && case "$VN" in *$LF*) (exit 1) ;; v[0-9]*) VN="$(dirty $VN)" esac; then VN=$(echo "$VN" | sed -e 's/-/./g'); else read COMMIT COMMIT_SUBJECT </dev/null) EOF if [ -z $COMMIT ]; then VN="${DEF_VER}+" else VN="$(dirty ${DEF_VER}.git$COMMIT)" fi fi echo $VN ndctl-61.2/git-version-gen000077500000000000000000000004421331777607200155260ustar00rootroot00000000000000#!/bin/sh GVF=version.m4 if test -r $GVF; then VC=$(sed -e 's/m4_define(\[GIT_VERSION], \[//' <$GVF) VC=$(echo $VC | sed -e 's/\])//') else VC=unset fi VN=$(./git-version) test "$VN" = "$VC" || { echo >&2 "GIT_VERSION = $VN" echo "m4_define([GIT_VERSION], [$VN])" >$GVF exit 0 } ndctl-61.2/licenses/000077500000000000000000000000001331777607200143705ustar00rootroot00000000000000ndctl-61.2/licenses/BSD-MIT000066400000000000000000000017771331777607200153660ustar00rootroot00000000000000Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ndctl-61.2/licenses/CC0000066400000000000000000000143571331777607200146720ustar00rootroot00000000000000Statement of Purpose The laws of most jurisdictions throughout the world automatically confer exclusive Copyright and Related Rights (defined below) upon the creator and subsequent owner(s) (each and all, an "owner") of an original work of authorship and/or a database (each, a "Work"). Certain owners wish to permanently relinquish those rights to a Work for the purpose of contributing to a commons of creative, cultural and scientific works ("Commons") that the public can reliably and without fear of later claims of infringement build upon, modify, incorporate in other works, reuse and redistribute as freely as possible in any form whatsoever and for any purposes, including without limitation commercial purposes. These owners may contribute to the Commons to promote the ideal of a free culture and the further production of creative, cultural and scientific works, or to gain reputation or greater distribution for their Work in part through the use and efforts of others. For these and/or other purposes and motivations, and without any expectation of additional consideration or compensation, the person associating CC0 with a Work (the "Affirmer"), to the extent that he or she is an owner of Copyright and Related Rights in the Work, voluntarily elects to apply CC0 to the Work and publicly distribute the Work under its terms, with knowledge of his or her Copyright and Related Rights in the Work and the meaning and intended legal effect of CC0 on those rights. 1. Copyright and Related Rights. A Work made available under CC0 may be protected by copyright and related or neighboring rights ("Copyright and Related Rights"). Copyright and Related Rights include, but are not limited to, the following: the right to reproduce, adapt, distribute, perform, display, communicate, and translate a Work; moral rights retained by the original author(s) and/or performer(s); publicity and privacy rights pertaining to a person's image or likeness depicted in a Work; rights protecting against unfair competition in regards to a Work, subject to the limitations in paragraph 4(a), below; rights protecting the extraction, dissemination, use and reuse of data in a Work; database rights (such as those arising under Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, and under any national implementation thereof, including any amended or successor version of such directive); and other similar, equivalent or corresponding rights throughout the world based on applicable law or treaty, and any national implementations thereof. 2. Waiver. To the greatest extent permitted by, but not in contravention of, applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and unconditionally waives, abandons, and surrenders all of Affirmer's Copyright and Related Rights and associated claims and causes of action, whether now known or unknown (including existing as well as future claims and causes of action), in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each member of the public at large and to the detriment of Affirmer's heirs and successors, fully intending that such Waiver shall not be subject to revocation, rescission, cancellation, termination, or any other legal or equitable action to disrupt the quiet enjoyment of the Work by the public as contemplated by Affirmer's express Statement of Purpose. 3. Public License Fallback. Should any part of the Waiver for any reason be judged legally invalid or ineffective under applicable law, then the Waiver shall be preserved to the maximum extent permitted taking into account Affirmer's express Statement of Purpose. In addition, to the extent the Waiver is so judged Affirmer hereby grants to each affected person a royalty-free, non transferable, non sublicensable, non exclusive, irrevocable and unconditional license to exercise Affirmer's Copyright and Related Rights in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "License"). The License shall be deemed effective as of the date CC0 was applied by Affirmer to the Work. Should any part of the License for any reason be judged legally invalid or ineffective under applicable law, such partial invalidity or ineffectiveness shall not invalidate the remainder of the License, and in such case Affirmer hereby affirms that he or she will not (i) exercise any of his or her remaining Copyright and Related Rights in the Work or (ii) assert any associated claims and causes of action with respect to the Work, in either case contrary to Affirmer's express Statement of Purpose. 4. Limitations and Disclaimers. No trademark or patent rights held by Affirmer are waived, abandoned, surrendered, licensed or otherwise affected by this document. Affirmer offers the Work as-is and makes no representations or warranties of any kind concerning the Work, express, implied, statutory or otherwise, including without limitation warranties of title, merchantability, fitness for a particular purpose, non infringement, or the absence of latent or other defects, accuracy, or the present or absence of errors, whether or not discoverable, all to the greatest extent permissible under applicable law. Affirmer disclaims responsibility for clearing rights of other persons that may apply to the Work or any use thereof, including without limitation any person's Copyright and Related Rights in the Work. Further, Affirmer disclaims responsibility for obtaining any necessary consents, permissions or other rights required for any use of the Work. Affirmer understands and acknowledges that Creative Commons is not a party to this document and has no duty or obligation with respect to this CC0 or use of the Work. ndctl-61.2/m4/000077500000000000000000000000001331777607200131035ustar00rootroot00000000000000ndctl-61.2/m4/.gitignore000066400000000000000000000001001331777607200150620ustar00rootroot00000000000000libtool.m4 ltoptions.m4 ltsugar.m4 ltversion.m4 lt~obsolete.m4 ndctl-61.2/make-git-snapshot.sh000077500000000000000000000011501331777607200164520ustar00rootroot00000000000000#!/bin/bash set -e NAME=ndctl REFDIR="$HOME/git/ndctl" # for faster cloning, if available UPSTREAM=$REFDIR #TODO update once we have a public upstream OUTDIR=$HOME/rpmbuild/SOURCES [ -n "$1" ] && HEAD="$1" || HEAD="HEAD" WORKDIR="$(mktemp -d --tmpdir "$NAME.XXXXXXXXXX")" trap 'rm -rf $WORKDIR' exit [ -d "$REFDIR" ] && REFERENCE="--reference $REFDIR" git clone $REFERENCE "$UPSTREAM" "$WORKDIR" VERSION=$(./git-version) DIRNAME="ndctl-${VERSION}" git archive --remote="$WORKDIR" --format=tar --prefix="$DIRNAME/" HEAD | gzip > $OUTDIR/"ndctl-${VERSION}.tar.gz" echo "Written $OUTDIR/ndctl-${VERSION}.tar.gz" ndctl-61.2/ndctl.spec.in000066400000000000000000000101621331777607200151500ustar00rootroot00000000000000Name: ndctl Version: VERSION Release: 1%{?dist} Summary: Manage "libnvdimm" subsystem devices (Non-volatile Memory) License: GPLv2 Group: System Environment/Base Url: https://github.com/pmem/ndctl Source0: https://github.com/pmem/%{name}/archive/v%{version}.tar.gz#/%{name}-%{version}.tar.gz Requires: LNAME%{?_isa} = %{version}-%{release} Requires: DAX_LNAME%{?_isa} = %{version}-%{release} BuildRequires: autoconf BuildRequires: asciidoc BuildRequires: xmlto BuildRequires: automake BuildRequires: libtool BuildRequires: pkgconfig BuildRequires: pkgconfig(libkmod) BuildRequires: pkgconfig(libudev) BuildRequires: pkgconfig(uuid) BuildRequires: pkgconfig(json-c) BuildRequires: pkgconfig(bash-completion) %description Utility library for managing the "libnvdimm" subsystem. The "libnvdimm" subsystem defines a kernel device model and control message interface for platform NVDIMM resources like those defined by the ACPI 6+ NFIT (NVDIMM Firmware Interface Table). %package -n DNAME Summary: Development files for libndctl License: LGPLv2 Group: Development/Libraries Requires: LNAME%{?_isa} = %{version}-%{release} %description -n DNAME The %{name}-devel package contains libraries and header files for developing applications that use %{name}. %package -n daxctl Summary: Manage Device-DAX instances License: GPLv2 Group: System Environment/Base Requires: DAX_LNAME%{?_isa} = %{version}-%{release} %description -n daxctl The daxctl utility provides enumeration and provisioning commands for the Linux kernel Device-DAX facility. This facility enables DAX mappings of performance / feature differentiated memory without need of a filesystem. %package -n DAX_DNAME Summary: Development files for libdaxctl License: LGPLv2 Group: Development/Libraries Requires: DAX_LNAME%{?_isa} = %{version}-%{release} %description -n DAX_DNAME The %{name}-devel package contains libraries and header files for developing applications that use %{name}, a library for enumerating "Device DAX" devices. Device DAX is a facility for establishing DAX mappings of performance / feature-differentiated memory. %package -n LNAME Summary: Management library for "libnvdimm" subsystem devices (Non-volatile Memory) License: LGPLv2 Group: System Environment/Libraries Requires: DAX_LNAME%{?_isa} = %{version}-%{release} %description -n LNAME Libraries for %{name}. %package -n DAX_LNAME Summary: Management library for "Device DAX" devices License: LGPLv2 Group: System Environment/Libraries %description -n DAX_LNAME Device DAX is a facility for establishing DAX mappings of performance / feature-differentiated memory. DAX_LNAME provides an enumeration / control API for these devices. %prep %setup -q ndctl-%{version} %build echo %{version} > version ./autogen.sh %configure --disable-static --disable-silent-rules make %{?_smp_mflags} %install %make_install find $RPM_BUILD_ROOT -name '*.la' -exec rm -f {} ';' %check make check %post -n LNAME -p /sbin/ldconfig %postun -n LNAME -p /sbin/ldconfig %post -n DAX_LNAME -p /sbin/ldconfig %postun -n DAX_LNAME -p /sbin/ldconfig %define bashcompdir %(pkg-config --variable=completionsdir bash-completion) %files %defattr(-,root,root) %license util/COPYING licenses/BSD-MIT licenses/CC0 %{_bindir}/ndctl %{_mandir}/man1/ndctl* %{bashcompdir}/ %files -n daxctl %defattr(-,root,root) %license util/COPYING licenses/BSD-MIT licenses/CC0 %{_bindir}/daxctl %{_mandir}/man1/daxctl* %files -n LNAME %defattr(-,root,root) %doc README.md %license COPYING licenses/BSD-MIT licenses/CC0 %{_libdir}/libndctl.so.* %files -n DAX_LNAME %defattr(-,root,root) %doc README.md %license COPYING licenses/BSD-MIT licenses/CC0 %{_libdir}/libdaxctl.so.* %files -n DNAME %defattr(-,root,root) %license COPYING %{_includedir}/ndctl/ %{_libdir}/libndctl.so %{_libdir}/pkgconfig/libndctl.pc %files -n DAX_DNAME %defattr(-,root,root) %license COPYING %{_includedir}/daxctl/ %{_libdir}/libdaxctl.so %{_libdir}/pkgconfig/libdaxctl.pc %changelog * Fri May 27 2016 Dan Williams - 53-1 - add daxctl-libs + daxctl-devel packages - add bash completion * Mon Apr 04 2016 Dan Williams - 52-1 - Initial rpm submission to Fedora ndctl-61.2/ndctl/000077500000000000000000000000001331777607200136675ustar00rootroot00000000000000ndctl-61.2/ndctl/Makefile.am000066400000000000000000000013721331777607200157260ustar00rootroot00000000000000include $(top_srcdir)/Makefile.am.in bin_PROGRAMS = ndctl ndctl_SOURCES = ndctl.c \ bus.c \ create-nfit.c \ namespace.c \ check.c \ region.c \ dimm.c \ ../util/log.c \ list.c \ test.c \ ../util/json.c \ util/json-smart.c \ util/json-firmware.c \ inject-error.c \ inject-smart.c if ENABLE_DESTRUCTIVE ndctl_SOURCES += ../test/blk_namespaces.c \ ../test/pmem_namespaces.c ndctl_SOURCES += bat.c endif ndctl_LDADD =\ lib/libndctl.la \ ../daxctl/lib/libdaxctl.la \ ../libutil.a \ $(UUID_LIBS) \ $(KMOD_LIBS) \ $(JSON_LIBS) if ENABLE_TEST ndctl_SOURCES += ../test/libndctl.c \ ../test/dsm-fail.c \ ../util/sysfs.c \ ../test/dpa-alloc.c \ ../test/parent-uuid.c \ ../test/multi-pmem.c \ ../test/core.c endif ndctl-61.2/ndctl/action.h000066400000000000000000000005141331777607200153150ustar00rootroot00000000000000/* * Copyright(c) 2015-2017 Intel Corporation. All rights reserved. * * SPDX-License-Identifier: GPL-2.0 */ #ifndef __NDCTL_ACTION_H__ #define __NDCTL_ACTION_H__ enum device_action { ACTION_ENABLE, ACTION_DISABLE, ACTION_CREATE, ACTION_DESTROY, ACTION_CHECK, ACTION_WAIT, ACTION_START, }; #endif /* __NDCTL_ACTION_H__ */ ndctl-61.2/ndctl/bat.c000066400000000000000000000032611331777607200146030ustar00rootroot00000000000000/* * Copyright(c) 2014 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify it * under the terms of version 2 of the GNU General Public License as * published by the Free Software Foundation. * * 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 * General Public License for more details. */ #include #include #include #include #include int cmd_bat(int argc, const char **argv, void *ctx) { int loglevel = LOG_DEBUG, i, rc; struct ndctl_test *test; bool force = false; const char * const u[] = { "ndctl bat []", NULL }; const struct option options[] = { OPT_INTEGER('l', "loglevel", &loglevel, "set the log level (default LOG_DEBUG)"), OPT_BOOLEAN('f', "force", &force, "force run all tests regardless of required kernel"), OPT_END(), }; argc = parse_options(argc, argv, options, u, 0); for (i = 0; i < argc; i++) error("unknown parameter \"%s\"\n", argv[i]); if (argc) usage_with_options(u, options); if (force) test = ndctl_test_new(UINT_MAX); else test = ndctl_test_new(0); if (!test) { fprintf(stderr, "failed to initialize test\n"); return EXIT_FAILURE; } rc = test_blk_namespaces(loglevel, test, ctx); fprintf(stderr, "test_blk_namespaces: %s\n", rc ? "FAIL" : "PASS"); if (rc && rc != 77) return rc; rc = test_pmem_namespaces(loglevel, test, ctx); fprintf(stderr, "test_pmem_namespaces: %s\n", rc ? "FAIL" : "PASS"); return ndctl_test_result(test, rc); } ndctl-61.2/ndctl/bus.c000066400000000000000000000054571331777607200146370ustar00rootroot00000000000000/* SPDX-License-Identifier: GPL-2.0 */ /* Copyright(c) 2015-2018 Intel Corporation. All rights reserved. */ #include #include #include #include #include "action.h" #include #include #include #include #include #include #include #include static struct { bool verbose; } param; static const struct option bus_options[] = { OPT_BOOLEAN('v',"verbose", ¶m.verbose, "turn on debug"), OPT_END(), }; static int scrub_action(struct ndctl_bus *bus, enum device_action action) { switch (action) { case ACTION_WAIT: return ndctl_bus_wait_for_scrub_completion(bus); case ACTION_START: return ndctl_bus_start_scrub(bus); default: return -EINVAL; } } static int bus_action(int argc, const char **argv, const char *usage, const struct option *options, enum device_action action, struct ndctl_ctx *ctx) { const char * const u[] = { usage, NULL }; struct json_object *jbuses, *jbus; int i, rc, success = 0, fail = 0; struct ndctl_bus *bus; const char *all = "all"; argc = parse_options(argc, argv, options, u, 0); if (param.verbose) ndctl_set_log_priority(ctx, LOG_DEBUG); if (argc == 0) { argc = 1; argv = &all; } else for (i = 0; i < argc; i++) if (strcmp(argv[i], "all") == 0) { argv[0] = "all"; argc = 1; break; } jbuses = json_object_new_array(); if (!jbuses) return -ENOMEM; for (i = 0; i < argc; i++) { int found = 0; ndctl_bus_foreach(ctx, bus) { if (!util_bus_filter(bus, argv[i])) continue; found++; rc = scrub_action(bus, action); if (rc == 0) { success++; jbus = util_bus_to_json(bus); if (jbus) json_object_array_add(jbuses, jbus); } else if (!fail) fail = rc; } if (!found && param.verbose) fprintf(stderr, "no bus matches id: %s\n", argv[i]); } if (success) util_display_json_array(stdout, jbuses, JSON_C_TO_STRING_PRETTY); else json_object_put(jbuses); if (success) return success; return fail ? fail : -ENXIO; } int cmd_start_scrub(int argc, const char **argv, void *ctx) { char *usage = "ndctl start-scrub [

... ] []"; int start = bus_action(argc, argv, usage, bus_options, ACTION_START, ctx); if (start <= 0) { fprintf(stderr, "error starting scrub: %s\n", strerror(-start)); return start; } else { return 0; } } int cmd_wait_scrub(int argc, const char **argv, void *ctx) { char *usage = "ndctl wait-scrub [

... ] []"; int wait = bus_action(argc, argv, usage, bus_options, ACTION_WAIT, ctx); if (wait <= 0) { fprintf(stderr, "error waiting for scrub completion: %s\n", strerror(-wait)); return wait; } else { return 0; } } ndctl-61.2/ndctl/check.c000066400000000000000000001013721331777607200151140ustar00rootroot00000000000000/* * Copyright(c) 2015-2016 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify it * under the terms of version 2 of the GNU General Public License as * published by the Free Software Foundation. * * 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 * General Public License for more details. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include struct check_opts { bool verbose; bool force; bool repair; bool logfix; }; struct btt_chk { char *path; int fd; uuid_t parent_uuid; unsigned long long rawsize; unsigned long long nlba; int start_off; int num_arenas; long sys_page_size; struct arena_info *arena; struct check_opts *opts; struct log_ctx ctx; }; struct arena_info { struct arena_map map; u64 size; /* Total bytes for this arena */ u64 external_lba_start; u32 internal_nlba; u32 internal_lbasize; u32 external_nlba; u32 external_lbasize; u32 nfree; u16 version_major; u16 version_minor; u64 nextoff; u64 infooff; u64 dataoff; u64 mapoff; u64 logoff; u64 info2off; u32 flags; int num; struct btt_chk *bttc; int log_index[2]; }; static sigjmp_buf sj_env; static void sigbus_hdl(int sig, siginfo_t *siginfo, void *ptr) { siglongjmp(sj_env, 1); } static int repair_msg(struct btt_chk *bttc) { info(bttc, " Run with --repair to make the changes\n"); return 0; } /** * btt_read_info - read an info block from a given offset * @bttc: the main btt_chk structure for this btt * @btt_sb: struct btt_sb where the info block will be copied into * @offset: offset in the raw namespace to read the info block from * * This will also use 'pread' to read the info block, and not mmap+loads * as this is used before the mappings are set up. */ static int btt_read_info(struct btt_chk *bttc, struct btt_sb *btt_sb, u64 off) { ssize_t size; size = pread(bttc->fd, btt_sb, sizeof(*btt_sb), off); if (size < 0) { err(bttc, "unable to read first info block: %s\n", strerror(errno)); return -errno; } if (size != sizeof(*btt_sb)) { err(bttc, "short read of first info block: %ld\n", size); return -ENXIO; } return 0; } /** * btt_write_info - write an info block to the given offset * @bttc: the main btt_chk structure for this btt * @btt_sb: struct btt_sb where the info block will be copied from * @offset: offset in the raw namespace to write the info block to * * This will also use 'pwrite' to write the info block, and not mmap+stores * as this is used before the mappings are set up. */ static int btt_write_info(struct btt_chk *bttc, struct btt_sb *btt_sb, u64 off) { ssize_t size; int rc; if (!bttc->opts->repair) { err(bttc, "BTT info block at offset %#lx needs to be restored\n", off); repair_msg(bttc); return -EIO; } info(bttc, "Restoring BTT info block at offset %#lx\n", off); size = pwrite(bttc->fd, btt_sb, sizeof(*btt_sb), off); if (size < 0) { err(bttc, "unable to write the info block: %s\n", strerror(errno)); return -errno; } if (size != sizeof(*btt_sb)) { err(bttc, "short write of the info block: %ld\n", size); return -ENXIO; } rc = fsync(bttc->fd); if (rc < 0) return -errno; return 0; } /** * btt_copy_to_info2 - restore the backup info block using the main one * @a: the arena_info handle for this arena * * Called when a corrupted backup info block is detected. Copies the * main info block over to the backup location. This is done using * mmap + stores, and thus needs a msync. */ static int btt_copy_to_info2(struct arena_info *a) { void *ms_align; size_t ms_size; if (!a->bttc->opts->repair) { err(a->bttc, "Arena %d: BTT info2 needs to be restored\n", a->num); return repair_msg(a->bttc); } printf("Arena %d: Restoring BTT info2\n", a->num); memcpy(a->map.info2, a->map.info, BTT_INFO_SIZE); ms_align = (void *)rounddown((u64)a->map.info2, a->bttc->sys_page_size); ms_size = max(BTT_INFO_SIZE, a->bttc->sys_page_size); if (msync(ms_align, ms_size, MS_SYNC) < 0) return -errno; return 0; } /* * btt_map_lookup - given a pre-map Arena Block Address, return the post-map ABA * @a: the arena_info handle for this arena * @lba: the logical block address for which we are performing the lookup * * This will correctly account for map entries in the 'initial state' */ static u32 btt_map_lookup(struct arena_info *a, u32 lba) { u32 raw_mapping; raw_mapping = le32_to_cpu(a->map.map[lba]); if (raw_mapping & MAP_ENT_NORMAL) return raw_mapping & MAP_LBA_MASK; else return lba; } static int btt_map_write(struct arena_info *a, u32 lba, u32 mapping) { void *ms_align; if (!a->bttc->opts->repair) { err(a->bttc, "Arena %d: map[%#x] needs to be updated to %#x\n", a->num, lba, mapping); return repair_msg(a->bttc); } info(a->bttc, "Arena %d: Updating map[%#x] to %#x\n", a->num, lba, mapping); /* * We want to set neither of the Z or E flags, and in the actual * layout, this means setting the bit positions of both to '1' to * indicate a 'normal' map entry */ mapping |= MAP_ENT_NORMAL; a->map.map[lba] = cpu_to_le32(mapping); ms_align = (void *)rounddown((u64)&a->map.map[lba], a->bttc->sys_page_size); if (msync(ms_align, a->bttc->sys_page_size, MS_SYNC) < 0) return -errno; return 0; } static void btt_log_group_read(struct arena_info *a, u32 lane, struct log_group *log) { memcpy(log, &a->map.log[lane], LOG_GRP_SIZE); } static void btt_log_group_write(struct arena_info *a, u32 lane, struct log_group *log) { memcpy(&a->map.log[lane], log, LOG_GRP_SIZE); } static u32 log_seq(struct log_group *log, int log_idx) { return le32_to_cpu(log->ent[log_idx].seq); } /* * This function accepts two log entries, and uses the sequence number to * find the 'older' entry. The return value indicates which of the two was * the 'old' entry */ static int btt_log_get_old(struct arena_info *a, struct log_group *log) { int idx0 = a->log_index[0]; int idx1 = a->log_index[1]; int old; if (log_seq(log, idx0) == 0) { log->ent[idx0].seq = cpu_to_le32(1); return 0; } if (log_seq(log, idx0) < log_seq(log, idx1)) { if ((log_seq(log, idx1) - log_seq(log, idx0)) == 1) old = 0; else old = 1; } else { if ((log_seq(log, idx0) - log_seq(log, idx1)) == 1) old = 1; else old = 0; } return old; } static int btt_log_read(struct arena_info *a, u32 lane, struct log_entry *ent) { int new_ent; struct log_group log; if (ent == NULL) return -EINVAL; btt_log_group_read(a, lane, &log); new_ent = 1 - btt_log_get_old(a, &log); memcpy(ent, &log.ent[a->log_index[new_ent]], LOG_ENT_SIZE); return 0; } static int btt_checksum_verify(struct btt_sb *btt_sb) { uint64_t sum; le64 sum_save; BUILD_BUG_ON(sizeof(struct btt_sb) != SZ_4K); sum_save = btt_sb->checksum; btt_sb->checksum = 0; sum = fletcher64(btt_sb, sizeof(*btt_sb), 1); if (sum != sum_save) return 1; /* restore the checksum in the buffer */ btt_sb->checksum = sum_save; return 0; } /* * Never pass a mmapped buffer to this as it will attempt to write to * the buffer, and we want writes to only happened in a controlled fashion. * In the non --repair case, even if such a buffer is passed, the write will * result in a fault due to the readonly mmap flags. */ static int btt_info_verify(struct btt_chk *bttc, struct btt_sb *btt_sb) { if (memcmp(btt_sb->signature, BTT_SIG, BTT_SIG_LEN) != 0) return -ENXIO; if (!uuid_is_null(btt_sb->parent_uuid)) if (uuid_compare(bttc->parent_uuid, btt_sb->parent_uuid) != 0) return -ENXIO; if (btt_checksum_verify(btt_sb)) return -ENXIO; return 0; } static int btt_info_read_verify(struct btt_chk *bttc, struct btt_sb *btt_sb, u64 off) { int rc; rc = btt_read_info(bttc, btt_sb, off); if (rc) return rc; rc = btt_info_verify(bttc, btt_sb); if (rc) return rc; return 0; } enum btt_errcodes { BTT_OK = 0, BTT_LOG_EQL_SEQ = 0x100, BTT_LOG_OOB_SEQ, BTT_LOG_OOB_LBA, BTT_LOG_OOB_OLD, BTT_LOG_OOB_NEW, BTT_LOG_MAP_ERR, BTT_MAP_OOB, BTT_BITMAP_ERROR, BTT_LOGFIX_ERR, }; static void btt_xlat_status(struct arena_info *a, int errcode) { switch(errcode) { case BTT_OK: break; case BTT_LOG_EQL_SEQ: err(a->bttc, "arena %d: found a pair of log entries with the same sequence number\n", a->num); break; case BTT_LOG_OOB_SEQ: err(a->bttc, "arena %d: found a log entry with an out of bounds sequence number\n", a->num); break; case BTT_LOG_OOB_LBA: err(a->bttc, "arena %d: found a log entry with an out of bounds LBA\n", a->num); break; case BTT_LOG_OOB_OLD: err(a->bttc, "arena %d: found a log entry with an out of bounds 'old' mapping\n", a->num); break; case BTT_LOG_OOB_NEW: err(a->bttc, "arena %d: found a log entry with an out of bounds 'new' mapping\n", a->num); break; case BTT_LOG_MAP_ERR: info(a->bttc, "arena %d: found a log entry that does not match with a map entry\n", a->num); break; case BTT_MAP_OOB: err(a->bttc, "arena %d: found a map entry that is out of bounds\n", a->num); break; case BTT_BITMAP_ERROR: err(a->bttc, "arena %d: bitmap error: internal blocks are incorrectly referenced\n", a->num); break; case BTT_LOGFIX_ERR: err(a->bttc, "arena %d: rewrite-log error: log may be in an unknown/unrecoverable state\n", a->num); break; default: err(a->bttc, "arena %d: unknown error: %d\n", a->num, errcode); } } /* Check that log entries are self consistent */ static int btt_check_log_entries(struct arena_info *a) { int idx0 = a->log_index[0]; int idx1 = a->log_index[1]; unsigned int i; int rc = 0; /* * First, check both 'slots' for sequence numbers being distinct * and in bounds */ for (i = 0; i < a->nfree; i++) { struct log_group *log = &a->map.log[i]; if (log_seq(log, idx0) == log_seq(log, idx1)) return BTT_LOG_EQL_SEQ; if (log_seq(log, idx0) > 3 || log_seq(log, idx1) > 3) return BTT_LOG_OOB_SEQ; } /* * Next, check only the 'new' slot in each lane for the remaining * fields being in bounds */ for (i = 0; i < a->nfree; i++) { struct log_entry ent; rc = btt_log_read(a, i, &ent); if (rc) return rc; if (ent.lba >= a->external_nlba) return BTT_LOG_OOB_LBA; if (ent.old_map >= a->internal_nlba) return BTT_LOG_OOB_OLD; if (ent.new_map >= a->internal_nlba) return BTT_LOG_OOB_NEW; } return rc; } /* Check that map entries are self consistent */ static int btt_check_map_entries(struct arena_info *a) { unsigned int i; u32 mapping; for (i = 0; i < a->external_nlba; i++) { mapping = btt_map_lookup(a, i); if (mapping >= a->internal_nlba) return BTT_MAP_OOB; } return 0; } /* Check that each flog entry has the correct corresponding map entry */ static int btt_check_log_map(struct arena_info *a) { unsigned int i; u32 mapping; int rc = 0, rc_saved = 0; for (i = 0; i < a->nfree; i++) { struct log_entry ent; rc = btt_log_read(a, i, &ent); if (rc) return rc; mapping = btt_map_lookup(a, ent.lba); /* * Case where the flog was written, but map couldn't be * updated. The kernel should also be able to detect and * fix this condition. */ if (ent.new_map != mapping && ent.old_map == mapping) { info(a->bttc, "arena %d: log[%d].new_map (%#x) doesn't match map[%#x] (%#x)\n", a->num, i, ent.new_map, ent.lba, mapping); rc = btt_map_write(a, ent.lba, ent.new_map); if (rc) rc_saved = rc; } } return rc_saved ? BTT_LOG_MAP_ERR : 0; } static int btt_check_info2(struct arena_info *a) { /* * Repair info2 if needed. The main info-block can be trusted * as it has been verified during arena discovery */ if(memcmp(a->map.info2, a->map.info, BTT_INFO_SIZE)) return btt_copy_to_info2(a); return 0; } /* * This will create a bitmap where each bit corresponds to an internal * 'block'. Between the BTT map and flog (representing 'free' blocks), * every single internal block must be represented exactly once. This * check will detect cases where either one or more blocks are never * referenced, or if a block is referenced more than once. */ static int btt_check_bitmap(struct arena_info *a) { unsigned long *bm; u32 i, btt_mapping; int rc = BTT_BITMAP_ERROR; bm = bitmap_alloc(a->internal_nlba); if (bm == NULL) return -ENOMEM; /* map 'external_nlba' number of map entries */ for (i = 0; i < a->external_nlba; i++) { btt_mapping = btt_map_lookup(a, i); if (test_bit(btt_mapping, bm)) { info(a->bttc, "arena %d: internal block %#x is referenced by two map entries\n", a->num, btt_mapping); goto out; } bitmap_set(bm, btt_mapping, 1); } /* map 'nfree' number of flog entries */ for (i = 0; i < a->nfree; i++) { struct log_entry ent; rc = btt_log_read(a, i, &ent); if (rc) goto out; if (test_bit(ent.old_map, bm)) { info(a->bttc, "arena %d: internal block %#x is referenced by two map/log entries\n", a->num, ent.old_map); rc = BTT_BITMAP_ERROR; goto out; } bitmap_set(bm, ent.old_map, 1); } /* check that the bitmap is full */ if (!bitmap_full(bm, a->internal_nlba)) rc = BTT_BITMAP_ERROR; out: free(bm); return rc; } static int btt_rewrite_log(struct arena_info *a) { struct log_group log; int rc; u32 i; info(a->bttc, "arena %d: rewriting log\n", a->num); /* * To rewrite the log, we implicitly use the 'new' padding scheme of * (0, 1) but resetting the log to a completely initial state (i.e. * slot-0 contains a made-up entry containing the 'free' block from * the existing current log entry, and a sequence number of '1'. All * other slots are zeroed. * * This way of rewriting the log is the most flexible as it can be * (ab)used to convert a new padding format back to the old one. * Since it only recreates slot-0, which is common between both * existing formats, an older kernel will simply initialize the free * list using those slot-0 entries, and run with it as though slot-2 * is the other valid slot. */ memset(&log, 0, LOG_GRP_SIZE); for (i = 0; i < a->nfree; i++) { struct log_entry ent; rc = btt_log_read(a, i, &ent); if (rc) return BTT_LOGFIX_ERR; log.ent[0].lba = ent.lba; log.ent[0].old_map = ent.old_map; log.ent[0].new_map = ent.new_map; log.ent[0].seq = 1; btt_log_group_write(a, i, &log); } return 0; } static int btt_check_arenas(struct btt_chk *bttc) { struct arena_info *a = NULL; int i, rc; for(i = 0; i < bttc->num_arenas; i++) { info(bttc, "checking arena %d\n", i); a = &bttc->arena[i]; rc = btt_check_log_entries(a); if (rc) break; rc = btt_check_map_entries(a); if (rc) break; rc = btt_check_log_map(a); if (rc) break; rc = btt_check_info2(a); if (rc) break; /* * bitmap test has to be after check_log_map so that any * pending log updates have been performed. Otherwise the * bitmap test may result in a false positive */ rc = btt_check_bitmap(a); if (rc) break; if (bttc->opts->logfix) { rc = btt_rewrite_log(a); if (rc) break; } } if (a && rc != BTT_OK) { btt_xlat_status(a, rc); return -ENXIO; } return 0; } /* * This copies over information from the info block to the arena_info struct. * The main difference is that all the offsets (infooff, mapoff etc) were * relative to the arena in the info block, but in arena_info, we use * arena_off to make these offsets absolute, i.e. relative to the start of * the raw namespace. */ static int btt_parse_meta(struct arena_info *arena, struct btt_sb *btt_sb, u64 arena_off) { arena->internal_nlba = le32_to_cpu(btt_sb->internal_nlba); arena->internal_lbasize = le32_to_cpu(btt_sb->internal_lbasize); arena->external_nlba = le32_to_cpu(btt_sb->external_nlba); arena->external_lbasize = le32_to_cpu(btt_sb->external_lbasize); arena->nfree = le32_to_cpu(btt_sb->nfree); if (arena->internal_nlba - arena->external_nlba != arena->nfree) return -ENXIO; if (arena->internal_lbasize != arena->external_lbasize) return -ENXIO; arena->version_major = le16_to_cpu(btt_sb->version_major); arena->version_minor = le16_to_cpu(btt_sb->version_minor); arena->nextoff = (btt_sb->nextoff == 0) ? 0 : (arena_off + le64_to_cpu(btt_sb->nextoff)); arena->infooff = arena_off; arena->dataoff = arena_off + le64_to_cpu(btt_sb->dataoff); arena->mapoff = arena_off + le64_to_cpu(btt_sb->mapoff); arena->logoff = arena_off + le64_to_cpu(btt_sb->logoff); arena->info2off = arena_off + le64_to_cpu(btt_sb->info2off); arena->size = (le64_to_cpu(btt_sb->nextoff) > 0) ? (le64_to_cpu(btt_sb->nextoff)) : (arena->info2off - arena->infooff + BTT_INFO_SIZE); arena->flags = le32_to_cpu(btt_sb->flags); if (btt_sb->flags & IB_FLAG_ERROR_MASK) { err(arena->bttc, "Info block error flag is set, aborting\n"); return -ENXIO; } return 0; } static bool ent_is_padding(struct log_entry *ent) { return (ent->lba == 0) && (ent->old_map == 0) && (ent->new_map == 0) && (ent->seq == 0); } /* * Detecting valid log indices: We read a log group, and iterate over its * four slots. We expect that a padding slot will be all-zeroes, and use this * to detect a padding slot vs. an actual entry. * * If a log_group is in the initial state, i.e. hasn't been used since the * creation of this BTT layout, it will have three of the four slots with * zeroes. We skip over these log_groups for the detection of log_index. If * all log_groups are in the initial state (i.e. the BTT has never been * written to), it is safe to assume the 'new format' of log entries in slots * (0, 1). */ static int log_set_indices(struct arena_info *arena) { bool idx_set = false, initial_state = true; int log_index[2] = {-1, -1}; struct log_group log; int j, next_idx = 0; u32 pad_count = 0; u32 i; for (i = 0; i < arena->nfree; i++) { btt_log_group_read(arena, i, &log); for (j = 0; j < 4; j++) { if (!idx_set) { if (ent_is_padding(&log.ent[j])) { pad_count++; continue; } else { /* Skip if index has been recorded */ if ((next_idx == 1) && (j == log_index[0])) continue; /* valid entry, record index */ log_index[next_idx] = j; next_idx++; } if (next_idx == 2) { /* two valid entries found */ idx_set = true; } else if (next_idx > 2) { /* too many valid indices */ return -ENXIO; } } else { /* * once the indices have been set, just verify * that all subsequent log groups are either in * their initial state or follow the same * indices. */ if (j == log_index[0]) { /* entry must be 'valid' */ if (ent_is_padding(&log.ent[j])) return -ENXIO; } else if (j == log_index[1]) { ; /* * log_index[1] can be padding if the * lane never got used and it is still * in the initial state (three 'padding' * entries) */ } else { /* entry must be invalid (padding) */ if (!ent_is_padding(&log.ent[j])) return -ENXIO; } } } /* * If any of the log_groups have more than one valid, * non-padding entry, then the we are no longer in the * initial_state */ if (pad_count < 3) initial_state = false; pad_count = 0; } if (!initial_state && !idx_set) return -ENXIO; /* * If all the entries in the log were in the initial state, * assume new padding scheme */ if (initial_state) log_index[1] = 1; /* * Only allow the known permutations of log/padding indices, * i.e. (0, 1), and (0, 2) */ if ((log_index[0] == 0) && ((log_index[1] == 1) || (log_index[1] == 2))) ; /* known index possibilities */ else { err(arena->bttc, "Found an unknown padding scheme\n"); return -ENXIO; } arena->log_index[0] = log_index[0]; arena->log_index[1] = log_index[1]; info(arena->bttc, "arena[%d]: log_index_0 = %d\n", arena->num, log_index[0]); info(arena->bttc, "arena[%d]: log_index_1 = %d\n", arena->num, log_index[1]); return 0; } static int btt_discover_arenas(struct btt_chk *bttc) { int ret = 0; struct arena_info *arena; struct btt_sb *btt_sb; size_t remaining = bttc->rawsize; size_t cur_off = bttc->start_off; u64 cur_nlba = 0; int i = 0; btt_sb = calloc(1, sizeof(*btt_sb)); if (!btt_sb) return -ENOMEM; while (remaining) { /* Alloc memory for arena */ arena = realloc(bttc->arena, (i + 1) * sizeof(*arena)); if (!arena) { ret = -ENOMEM; goto out; } else { bttc->arena = arena; arena = &bttc->arena[i]; /* zero the new memory */ memset(arena, 0, sizeof(*arena)); } arena->infooff = cur_off; ret = btt_read_info(bttc, btt_sb, cur_off); if (ret) goto out; if (btt_info_verify(bttc, btt_sb) != 0) { u64 offset; /* Try to find the backup info block */ if (remaining <= ARENA_MAX_SIZE) offset = rounddown(bttc->rawsize, SZ_4K) - BTT_INFO_SIZE; else offset = cur_off + ARENA_MAX_SIZE - BTT_INFO_SIZE; info(bttc, "Arena %d: Attempting recover info-block using info2\n", i); ret = btt_read_info(bttc, btt_sb, offset); if (ret) { err(bttc, "Unable to read backup info block (offset %#lx)\n", offset); goto out; } ret = btt_info_verify(bttc, btt_sb); if (ret) { err(bttc, "Backup info block (offset %#lx) verification failed\n", offset); goto out; } ret = btt_write_info(bttc, btt_sb, cur_off); if (ret) { err(bttc, "Restoration of the info block failed: %s (%d)\n", strerror(abs(ret)), ret); goto out; } } arena->num = i; arena->bttc = bttc; arena->external_lba_start = cur_nlba; ret = btt_parse_meta(arena, btt_sb, cur_off); if (ret) { err(bttc, "Problem parsing arena[%d] metadata\n", i); goto out; } remaining -= arena->size; cur_off += arena->size; cur_nlba += arena->external_nlba; i++; if (arena->nextoff == 0) break; } bttc->num_arenas = i; bttc->nlba = cur_nlba; info(bttc, "found %d BTT arena%s\n", bttc->num_arenas, (bttc->num_arenas > 1) ? "s" : ""); free(btt_sb); return ret; out: free(bttc->arena); free(btt_sb); return ret; } static int btt_create_mappings(struct btt_chk *bttc) { struct arena_info *a; int mmap_flags; int i; if (!bttc->opts->repair) mmap_flags = PROT_READ; else mmap_flags = PROT_READ|PROT_WRITE; for (i = 0; i < bttc->num_arenas; i++) { a = &bttc->arena[i]; a->map.info_len = BTT_INFO_SIZE; a->map.info = mmap(NULL, a->map.info_len, mmap_flags, MAP_SHARED, bttc->fd, a->infooff); if (a->map.info == MAP_FAILED) { err(bttc, "mmap arena[%d].info [sz = %#lx, off = %#lx] failed: %s\n", i, a->map.info_len, a->infooff, strerror(errno)); return -errno; } a->map.data_len = a->mapoff - a->dataoff; a->map.data = mmap(NULL, a->map.data_len, mmap_flags, MAP_SHARED, bttc->fd, a->dataoff); if (a->map.data == MAP_FAILED) { err(bttc, "mmap arena[%d].data [sz = %#lx, off = %#lx] failed: %s\n", i, a->map.data_len, a->dataoff, strerror(errno)); return -errno; } a->map.map_len = a->logoff - a->mapoff; a->map.map = mmap(NULL, a->map.map_len, mmap_flags, MAP_SHARED, bttc->fd, a->mapoff); if (a->map.map == MAP_FAILED) { err(bttc, "mmap arena[%d].map [sz = %#lx, off = %#lx] failed: %s\n", i, a->map.map_len, a->mapoff, strerror(errno)); return -errno; } a->map.log_len = a->info2off - a->logoff; a->map.log = mmap(NULL, a->map.log_len, mmap_flags, MAP_SHARED, bttc->fd, a->logoff); if (a->map.log == MAP_FAILED) { err(bttc, "mmap arena[%d].log [sz = %#lx, off = %#lx] failed: %s\n", i, a->map.log_len, a->logoff, strerror(errno)); return -errno; } a->map.info2_len = BTT_INFO_SIZE; a->map.info2 = mmap(NULL, a->map.info2_len, mmap_flags, MAP_SHARED, bttc->fd, a->info2off); if (a->map.info2 == MAP_FAILED) { err(bttc, "mmap arena[%d].info2 [sz = %#lx, off = %#lx] failed: %s\n", i, a->map.info2_len, a->info2off, strerror(errno)); return -errno; } } return 0; } static void btt_remove_mappings(struct btt_chk *bttc) { struct arena_info *a; int i; for (i = 0; i < bttc->num_arenas; i++) { a = &bttc->arena[i]; if (a->map.info) munmap(a->map.info, a->map.info_len); if (a->map.data) munmap(a->map.data, a->map.data_len); if (a->map.map) munmap(a->map.map, a->map.map_len); if (a->map.log) munmap(a->map.log, a->map.log_len); if (a->map.info2) munmap(a->map.info2, a->map.info2_len); } } static int btt_sb_get_expected_offset(struct btt_sb *btt_sb) { u16 version_major, version_minor; version_major = le16_to_cpu(btt_sb->version_major); version_minor = le16_to_cpu(btt_sb->version_minor); if (version_major == 1 && version_minor == 1) return BTT1_START_OFFSET; else if (version_major == 2 && version_minor == 0) return BTT2_START_OFFSET; else return -ENXIO; } static int __btt_recover_first_sb(struct btt_chk *bttc, int off) { int rc, est_arenas = 0; u64 offset, remaining; struct btt_sb *btt_sb; /* Estimate the number of arenas */ remaining = bttc->rawsize - off; while (remaining) { if (remaining < ARENA_MIN_SIZE && est_arenas == 0) return -EINVAL; if (remaining > ARENA_MAX_SIZE) { /* full-size arena */ remaining -= ARENA_MAX_SIZE; est_arenas++; continue; } if (remaining < ARENA_MIN_SIZE) { /* 'remaining' was too small for another arena */ break; } else { /* last, short arena */ remaining = 0; est_arenas++; break; } } info(bttc, "estimated arenas: %d, remaining bytes: %#lx\n", est_arenas, remaining); btt_sb = malloc(2 * sizeof(*btt_sb)); if (btt_sb == NULL) return -ENOMEM; /* Read the original first info block into btt_sb[0] */ rc = btt_read_info(bttc, &btt_sb[0], off); if (rc) goto out; /* Attepmt 1: try recovery from expected end of the first arena */ if (est_arenas == 1) offset = rounddown(bttc->rawsize - remaining, SZ_4K) - BTT_INFO_SIZE; else offset = ARENA_MAX_SIZE - BTT_INFO_SIZE + off; info(bttc, "Attempting recover info-block from end-of-arena offset %#lx\n", offset); rc = btt_info_read_verify(bttc, &btt_sb[1], offset); if (rc == 0) { int expected_offset = btt_sb_get_expected_offset(&btt_sb[1]); /* * The fact that the btt_sb is self-consistent doesn't tell us * what BTT version it was, if restoring from the end of the * arena. (i.e. a consistent sb may be found for any valid * start offset). Use the version information in the sb to * determine what the expected start offset is. */ if ((expected_offset < 0) || (expected_offset != off)) { rc = -ENXIO; goto out; } rc = btt_write_info(bttc, &btt_sb[1], off); goto out; } /* * Attempt 2: From the very end of 'rawsize', try to copy the fields * that are constant in every arena (only valid when multiple arenas * are present) */ if (est_arenas > 1) { offset = rounddown(bttc->rawsize - remaining, SZ_4K) - BTT_INFO_SIZE; info(bttc, "Attempting to recover info-block from end offset %#lx\n", offset); rc = btt_info_read_verify(bttc, &btt_sb[1], offset); if (rc) goto out; /* copy over the arena0 specific fields from btt_sb[0] */ btt_sb[1].flags = btt_sb[0].flags; btt_sb[1].external_nlba = btt_sb[0].external_nlba; btt_sb[1].internal_nlba = btt_sb[0].internal_nlba; btt_sb[1].nextoff = btt_sb[0].nextoff; btt_sb[1].dataoff = btt_sb[0].dataoff; btt_sb[1].mapoff = btt_sb[0].mapoff; btt_sb[1].logoff = btt_sb[0].logoff; btt_sb[1].info2off = btt_sb[0].info2off; btt_sb[1].checksum = btt_sb[0].checksum; rc = btt_info_verify(bttc, &btt_sb[1]); if (rc == 0) { rc = btt_write_info(bttc, &btt_sb[1], off); goto out; } } /* * Attempt 3: use info2off as-is, and check if we find a valid info * block at that location. */ offset = le32_to_cpu(btt_sb[0].info2off); if (offset > min(bttc->rawsize - BTT_INFO_SIZE, ARENA_MAX_SIZE - BTT_INFO_SIZE + off)) { rc = -ENXIO; goto out; } if (offset) { info(bttc, "Attempting to recover info-block from info2 offset %#lx\n", offset); rc = btt_info_read_verify(bttc, &btt_sb[1], offset + off); if (rc == 0) { rc = btt_write_info(bttc, &btt_sb[1], off); goto out; } } else rc = -ENXIO; out: free(btt_sb); return rc; } static int btt_recover_first_sb(struct btt_chk *bttc) { int offsets[BTT_NUM_OFFSETS] = { BTT1_START_OFFSET, BTT2_START_OFFSET, }; int i, rc; for (i = 0; i < BTT_NUM_OFFSETS; i++) { rc = __btt_recover_first_sb(bttc, offsets[i]); if (rc == 0) { bttc->start_off = offsets[i]; return rc; } } return rc; } int namespace_check(struct ndctl_namespace *ndns, bool verbose, bool force, bool repair, bool logfix) { const char *devname = ndctl_namespace_get_devname(ndns); struct check_opts __opts = { .verbose = verbose, .force = force, .repair = repair, .logfix = logfix, }, *opts = &__opts; int raw_mode, rc, disabled_flag = 0, open_flags; struct btt_sb *btt_sb; struct btt_chk *bttc; struct sigaction act; char path[50]; int i; bttc = calloc(1, sizeof(*bttc)); if (bttc == NULL) return -ENOMEM; log_init(&bttc->ctx, devname, "NDCTL_CHECK_NAMESPACE"); if (opts->verbose) bttc->ctx.log_priority = LOG_DEBUG; memset(&act, 0, sizeof(act)); act.sa_sigaction = sigbus_hdl; act.sa_flags = SA_SIGINFO; if (sigaction(SIGBUS, &act, 0)) { err(bttc, "Unable to set sigaction\n"); rc = -errno; goto out_bttc; } if (opts->logfix) { if (!opts->repair) { err(bttc, "--rewrite-log also requires --repair\n"); rc = -EINVAL; goto out_bttc; } info(bttc, "WARNING: interruption may cause unrecoverable metadata corruption\n"); } bttc->opts = opts; bttc->sys_page_size = sysconf(_SC_PAGESIZE); bttc->rawsize = ndctl_namespace_get_size(ndns); ndctl_namespace_get_uuid(ndns, bttc->parent_uuid); info(bttc, "checking %s\n", devname); if (ndctl_namespace_is_active(ndns)) { if (opts->force) { rc = ndctl_namespace_disable_safe(ndns); if (rc) goto out_bttc; disabled_flag = 1; } else { err(bttc, "%s: check aborted, namespace online\n", devname); rc = -EBUSY; goto out_bttc; } } /* In typical usage, the current raw_mode should be false. */ raw_mode = ndctl_namespace_get_raw_mode(ndns); /* * Putting the namespace into raw mode will allow us to access * the btt metadata. */ rc = ndctl_namespace_set_raw_mode(ndns, 1); if (rc < 0) { err(bttc, "%s: failed to set the raw mode flag: %s (%d)\n", devname, strerror(abs(rc)), rc); goto out_ns; } /* * Now enable the namespace. This will result in a pmem device * node showing up in /dev that is in raw mode. */ rc = ndctl_namespace_enable(ndns); if (rc != 0) { err(bttc, "%s: failed to enable in raw mode: %s (%d)\n", devname, strerror(abs(rc)), rc); goto out_ns; } sprintf(path, "/dev/%s", ndctl_namespace_get_block_device(ndns)); bttc->path = path; btt_sb = malloc(sizeof(*btt_sb)); if (btt_sb == NULL) { rc = -ENOMEM; goto out_ns; } if (!bttc->opts->repair) open_flags = O_RDONLY|O_EXCL; else open_flags = O_RDWR|O_EXCL; bttc->fd = open(bttc->path, open_flags); if (bttc->fd < 0) { err(bttc, "unable to open %s: %s\n", bttc->path, strerror(errno)); rc = -errno; goto out_sb; } /* * This is where we jump to if we receive a SIGBUS, prior to doing any * mmaped reads, and can safely abort */ if (sigsetjmp(sj_env, 1)) { err(bttc, "Received a SIGBUS\n"); err(bttc, "Metadata corruption found, recovery is not possible\n"); rc = -EFAULT; goto out_close; } /* Try reading a BTT1 info block first */ rc = btt_info_read_verify(bttc, btt_sb, BTT1_START_OFFSET); if (rc == 0) bttc->start_off = BTT1_START_OFFSET; if (rc) { /* Try reading a BTT2 info block */ rc = btt_info_read_verify(bttc, btt_sb, BTT2_START_OFFSET); if (rc == 0) bttc->start_off = BTT2_START_OFFSET; if (rc) { rc = btt_recover_first_sb(bttc); if (rc) { err(bttc, "Unable to recover any BTT info blocks\n"); goto out_close; } /* * btt_recover_first_sb will have set bttc->start_off * based on the version it found */ rc = btt_info_read_verify(bttc, btt_sb, bttc->start_off); if (rc) goto out_close; } } rc = btt_discover_arenas(bttc); if (rc) goto out_close; rc = btt_create_mappings(bttc); if (rc) goto out_close; for (i = 0; i < bttc->num_arenas; i++) { rc = log_set_indices(&bttc->arena[i]); if (rc) { err(bttc, "Unable to deduce log/padding indices\n"); goto out_close; } } rc = btt_check_arenas(bttc); btt_remove_mappings(bttc); out_close: close(bttc->fd); out_sb: free(btt_sb); out_ns: ndctl_namespace_set_raw_mode(ndns, raw_mode); ndctl_namespace_disable_invalidate(ndns); if (disabled_flag) if(ndctl_namespace_enable(ndns) < 0) err(bttc, "%s: failed to re-enable namespace\n", devname); out_bttc: free(bttc); return rc; } ndctl-61.2/ndctl/create-nfit.c000066400000000000000000000117631331777607200162440ustar00rootroot00000000000000/* * Copyright(c) 2014 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify it * under the terms of version 2 of the GNU General Public License as * published by the Free Software Foundation. * * 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 * General Public License for more details. */ #include #include #include #include #include #include #include #include #include #include #include #include #define DEFAULT_NFIT "local_nfit.bin" static const char *nfit_file = DEFAULT_NFIT; static LIST_HEAD(spas); struct spa { struct list_node list; unsigned long long size, offset; }; static int parse_add_spa(const struct option *option, const char *__arg, int unset) { struct spa *s = calloc(1, sizeof(struct spa)); char *arg = strdup(__arg); char *size, *offset; int rc = -ENOMEM; if (!s || !arg) goto err; rc = -EINVAL; size = arg; offset = strchr(arg, ','); if (!offset) goto err; *offset++ = '\0'; s->size = parse_size64(size); if (s->size == ULLONG_MAX) goto err; s->offset = parse_size64(offset); if (s->offset == ULLONG_MAX) goto err; list_add_tail(&spas, &s->list); free(arg); return 0; err: error("failed to parse --add-spa=%s\n", __arg); free(arg); free(s); return rc; } static unsigned char nfit_checksum(void *buf, size_t size) { unsigned char sum, *data = buf; size_t i; for (sum = 0, i = 0; i < size; i++) sum += data[i]; return 0 - sum; } static void writeq(unsigned long long v, void *a) { unsigned long long *p = a; *p = htole64(v); } static void writel(unsigned long v, void *a) { unsigned long *p = a; *p = htole32(v); } static void writew(unsigned short v, void *a) { unsigned short *p = a; *p = htole16(v); } static void writeb(unsigned char v, void *a) { unsigned char *p = a; *p = v; } static struct nfit *create_nfit(struct list_head *spa_list) { struct nfit_spa *nfit_spa; struct nfit *nfit; struct spa *s; size_t size; char *buf; int i; size = sizeof(struct nfit); list_for_each(spa_list, s, list) size += sizeof(struct nfit_spa); buf = calloc(1, size); if (!buf) return NULL; /* nfit header */ nfit = (struct nfit *) buf; memcpy(nfit->signature, "NFIT", 4); writel(size, &nfit->length); writeb(1, &nfit->revision); memcpy(nfit->oemid, "LOCAL", 6); writew(1, &nfit->oem_tbl_id); writel(1, &nfit->oem_revision); writel(0x80860000, &nfit->creator_id); writel(1, &nfit->creator_revision); nfit_spa = (struct nfit_spa *) (buf + sizeof(*nfit)); i = 1; list_for_each(spa_list, s, list) { writew(NFIT_TABLE_SPA, &nfit_spa->type); writew(sizeof(*nfit_spa), &nfit_spa->length); nfit_spa_uuid_pm(&nfit_spa->type_uuid); writew(i++, &nfit_spa->range_index); writeq(s->offset, &nfit_spa->spa_base); writeq(s->size, &nfit_spa->spa_length); nfit_spa++; } writeb(nfit_checksum(buf, size), &nfit->checksum); return nfit; } static int write_nfit(struct nfit *nfit, const char *file, int force) { int fd; ssize_t rc; mode_t mode = S_IRUSR|S_IRGRP|S_IWUSR|S_IWGRP; fd = open(file, O_RDWR|O_CREAT|O_EXCL, mode); if (fd < 0 && !force && errno == EEXIST) { error("\"%s\" exists, overwrite with --force\n", file); return -EEXIST; } else if (fd < 0 && force && errno == EEXIST) { fd = open(file, O_RDWR|O_CREAT|O_TRUNC, mode); } if (fd < 0) { error("Failed to open \"%s\": %s\n", file, strerror(errno)); return -errno; } rc = write(fd, nfit, le32toh(nfit->length)); close(fd); return rc; } struct ndctl_ctx; int cmd_create_nfit(int argc, const char **argv, void *ctx) { int i, rc = -ENXIO, force = 0; const char * const u[] = { "ndctl create-nfit []", NULL }; const struct option options[] = { OPT_CALLBACK('a', "add-spa", NULL, "size,offset", "add a system-physical-address range table entry", parse_add_spa), OPT_STRING('o', NULL, &nfit_file, "file", "output to (default: " DEFAULT_NFIT ")"), OPT_INCR('f', "force", &force, "overwrite if it already exists"), OPT_END(), }; struct spa *s, *_s; struct nfit *nfit = NULL; argc = parse_options(argc, argv, options, u, 0); for (i = 0; i < argc; i++) error("unknown parameter \"%s\"\n", argv[i]); if (list_empty(&spas)) error("specify at least one --add-spa= option\n"); if (argc || list_empty(&spas)) usage_with_options(u, options); nfit = create_nfit(&spas); if (!nfit) goto out; rc = write_nfit(nfit, nfit_file, force); if ((unsigned int) rc == le32toh(nfit->length)) { fprintf(stderr, "wrote %d bytes to %s\n", le32toh(nfit->length), nfit_file); rc = 0; } out: free(nfit); list_for_each_safe(&spas, s, _s, list) { list_del(&s->list); free(s); } return rc; } ndctl-61.2/ndctl/dimm.c000066400000000000000000000647241331777607200147760ustar00rootroot00000000000000/* * Copyright (c) 2016, Intel Corporation. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU Lesser General Public License, * version 2.1, as published by the Free Software Foundation. * * This program is distributed in the hope 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. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include struct action_context { struct json_object *jdimms; enum ndctl_namespace_version labelversion; FILE *f_out; FILE *f_in; struct update_context update; }; static int action_disable(struct ndctl_dimm *dimm, struct action_context *actx) { if (ndctl_dimm_is_active(dimm)) { fprintf(stderr, "%s is active, skipping...\n", ndctl_dimm_get_devname(dimm)); return -EBUSY; } return ndctl_dimm_disable(dimm); } static int action_enable(struct ndctl_dimm *dimm, struct action_context *actx) { return ndctl_dimm_enable(dimm); } static int action_zero(struct ndctl_dimm *dimm, struct action_context *actx) { return ndctl_dimm_zero_labels(dimm); } static struct json_object *dump_label_json(struct ndctl_dimm *dimm, struct ndctl_cmd *cmd_read, ssize_t size) { struct json_object *jarray = json_object_new_array(); struct json_object *jlabel = NULL; struct namespace_label nslabel; unsigned int slot = -1; ssize_t offset; if (!jarray) return NULL; for (offset = NSINDEX_ALIGN * 2; offset < size; offset += ndctl_dimm_sizeof_namespace_label(dimm)) { ssize_t len = min_t(ssize_t, ndctl_dimm_sizeof_namespace_label(dimm), size - offset); struct json_object *jobj; char uuid[40]; slot++; jlabel = json_object_new_object(); if (!jlabel) break; if (len < (ssize_t) ndctl_dimm_sizeof_namespace_label(dimm)) break; len = ndctl_cmd_cfg_read_get_data(cmd_read, &nslabel, len, offset); if (len < 0) break; if (le32_to_cpu(nslabel.slot) != slot) continue; uuid_unparse((void *) nslabel.uuid, uuid); jobj = json_object_new_string(uuid); if (!jobj) break; json_object_object_add(jlabel, "uuid", jobj); nslabel.name[NSLABEL_NAME_LEN - 1] = 0; jobj = json_object_new_string(nslabel.name); if (!jobj) break; json_object_object_add(jlabel, "name", jobj); jobj = json_object_new_int(le32_to_cpu(nslabel.slot)); if (!jobj) break; json_object_object_add(jlabel, "slot", jobj); jobj = json_object_new_int(le16_to_cpu(nslabel.position)); if (!jobj) break; json_object_object_add(jlabel, "position", jobj); jobj = json_object_new_int(le16_to_cpu(nslabel.nlabel)); if (!jobj) break; json_object_object_add(jlabel, "nlabel", jobj); jobj = json_object_new_int64(le64_to_cpu(nslabel.isetcookie)); if (!jobj) break; json_object_object_add(jlabel, "isetcookie", jobj); jobj = json_object_new_int64(le64_to_cpu(nslabel.lbasize)); if (!jobj) break; json_object_object_add(jlabel, "lbasize", jobj); jobj = json_object_new_int64(le64_to_cpu(nslabel.dpa)); if (!jobj) break; json_object_object_add(jlabel, "dpa", jobj); jobj = json_object_new_int64(le64_to_cpu(nslabel.rawsize)); if (!jobj) break; json_object_object_add(jlabel, "rawsize", jobj); json_object_array_add(jarray, jlabel); if (ndctl_dimm_sizeof_namespace_label(dimm) < 256) continue; uuid_unparse((void *) nslabel.type_guid, uuid); jobj = json_object_new_string(uuid); if (!jobj) break; json_object_object_add(jlabel, "type_guid", jobj); uuid_unparse((void *) nslabel.abstraction_guid, uuid); jobj = json_object_new_string(uuid); if (!jobj) break; json_object_object_add(jlabel, "abstraction_guid", jobj); } if (json_object_array_length(jarray) < 1) { json_object_put(jarray); if (jlabel) json_object_put(jlabel); jarray = NULL; } return jarray; } static struct json_object *dump_index_json(struct ndctl_cmd *cmd_read, ssize_t size) { struct json_object *jarray = json_object_new_array(); struct json_object *jindex = NULL; struct namespace_index nsindex; ssize_t offset; if (!jarray) return NULL; for (offset = 0; offset < NSINDEX_ALIGN * 2; offset += NSINDEX_ALIGN) { ssize_t len = min_t(ssize_t, sizeof(nsindex), size - offset); struct json_object *jobj; jindex = json_object_new_object(); if (!jindex) break; if (len < (ssize_t) sizeof(nsindex)) break; len = ndctl_cmd_cfg_read_get_data(cmd_read, &nsindex, len, offset); if (len < 0) break; nsindex.sig[NSINDEX_SIG_LEN - 1] = 0; jobj = json_object_new_string(nsindex.sig); if (!jobj) break; json_object_object_add(jindex, "signature", jobj); jobj = json_object_new_int(le16_to_cpu(nsindex.major)); if (!jobj) break; json_object_object_add(jindex, "major", jobj); jobj = json_object_new_int(le16_to_cpu(nsindex.minor)); if (!jobj) break; json_object_object_add(jindex, "minor", jobj); jobj = json_object_new_int(1 << (7 + nsindex.labelsize)); if (!jobj) break; json_object_object_add(jindex, "labelsize", jobj); jobj = json_object_new_int(le32_to_cpu(nsindex.seq)); if (!jobj) break; json_object_object_add(jindex, "seq", jobj); jobj = json_object_new_int(le32_to_cpu(nsindex.nslot)); if (!jobj) break; json_object_object_add(jindex, "nslot", jobj); json_object_array_add(jarray, jindex); } if (json_object_array_length(jarray) < 1) { json_object_put(jarray); if (jindex) json_object_put(jindex); jarray = NULL; } return jarray; } static struct json_object *dump_json(struct ndctl_dimm *dimm, struct ndctl_cmd *cmd_read, ssize_t size) { struct json_object *jdimm = json_object_new_object(); struct json_object *jlabel, *jobj, *jindex; if (!jdimm) return NULL; jindex = dump_index_json(cmd_read, size); if (!jindex) goto err_jindex; jlabel = dump_label_json(dimm, cmd_read, size); if (!jlabel) goto err_jlabel; jobj = json_object_new_string(ndctl_dimm_get_devname(dimm)); if (!jobj) goto err_jobj; json_object_object_add(jdimm, "dev", jobj); json_object_object_add(jdimm, "index", jindex); json_object_object_add(jdimm, "label", jlabel); return jdimm; err_jobj: json_object_put(jlabel); err_jlabel: json_object_put(jindex); err_jindex: json_object_put(jdimm); return NULL; } static int rw_bin(FILE *f, struct ndctl_cmd *cmd, ssize_t size, int rw) { char buf[4096]; ssize_t offset, write = 0; for (offset = 0; offset < size; offset += sizeof(buf)) { ssize_t len = min_t(ssize_t, sizeof(buf), size - offset), rc; if (rw) { len = fread(buf, 1, len, f); if (len == 0) break; rc = ndctl_cmd_cfg_write_set_data(cmd, buf, len, offset); if (rc < 0) return -ENXIO; write += len; } else { len = ndctl_cmd_cfg_read_get_data(cmd, buf, len, offset); if (len < 0) return len; rc = fwrite(buf, 1, len, f); if (rc != len) return -ENXIO; fflush(f); } } if (write) return ndctl_cmd_submit(cmd); return 0; } static int action_write(struct ndctl_dimm *dimm, struct action_context *actx) { struct ndctl_cmd *cmd_read, *cmd_write; ssize_t size; int rc = 0; if (ndctl_dimm_is_active(dimm)) { fprintf(stderr, "dimm is active, abort label write\n"); return -EBUSY; } cmd_read = ndctl_dimm_read_labels(dimm); if (!cmd_read) return -ENXIO; cmd_write = ndctl_dimm_cmd_new_cfg_write(cmd_read); if (!cmd_write) { ndctl_cmd_unref(cmd_read); return -ENXIO; } size = ndctl_cmd_cfg_read_get_size(cmd_read); rc = rw_bin(actx->f_in, cmd_write, size, 1); /* * If the dimm is already disabled the kernel is not holding a cached * copy of the label space. */ if (!ndctl_dimm_is_enabled(dimm)) goto out; rc = ndctl_dimm_disable(dimm); if (rc) goto out; rc = ndctl_dimm_enable(dimm); out: ndctl_cmd_unref(cmd_read); ndctl_cmd_unref(cmd_write); return rc; } static int action_read(struct ndctl_dimm *dimm, struct action_context *actx) { struct ndctl_cmd *cmd_read; ssize_t size; int rc = 0; cmd_read = ndctl_dimm_read_labels(dimm); if (!cmd_read) return -ENXIO; size = ndctl_cmd_cfg_read_get_size(cmd_read); if (actx->jdimms) { struct json_object *jdimm = dump_json(dimm, cmd_read, size); if (jdimm) json_object_array_add(actx->jdimms, jdimm); else rc = -ENOMEM; } else rc = rw_bin(actx->f_out, cmd_read, size, 0); ndctl_cmd_unref(cmd_read); return rc; } static int update_verify_input(struct action_context *actx) { int rc; struct stat st; rc = fstat(fileno(actx->f_in), &st); if (rc == -1) { rc = -errno; fprintf(stderr, "fstat failed: %s\n", strerror(errno)); return rc; } if (!S_ISREG(st.st_mode)) { fprintf(stderr, "Input not a regular file.\n"); return -EINVAL; } if (st.st_size == 0) { fprintf(stderr, "Input file size is 0.\n"); return -EINVAL; } actx->update.fw_size = st.st_size; return 0; } static int verify_fw_size(struct update_context *uctx) { struct fw_info *fw = &uctx->dimm_fw; if (uctx->fw_size > fw->store_size) { error("Firmware file size greater than DIMM store\n"); return -ENOSPC; } return 0; } static int submit_get_firmware_info(struct ndctl_dimm *dimm, struct action_context *actx) { struct update_context *uctx = &actx->update; struct fw_info *fw = &uctx->dimm_fw; struct ndctl_cmd *cmd; int rc; enum ND_FW_STATUS status; cmd = ndctl_dimm_cmd_new_fw_get_info(dimm); if (!cmd) return -ENXIO; rc = ndctl_cmd_submit(cmd); if (rc < 0) return rc; status = ndctl_cmd_fw_xlat_firmware_status(cmd); if (status != FW_SUCCESS) { fprintf(stderr, "GET FIRMWARE INFO on DIMM %s failed: %#x\n", ndctl_dimm_get_devname(dimm), status); return -ENXIO; } fw->store_size = ndctl_cmd_fw_info_get_storage_size(cmd); if (fw->store_size == UINT_MAX) return -ENXIO; fw->update_size = ndctl_cmd_fw_info_get_max_send_len(cmd); if (fw->update_size == UINT_MAX) return -ENXIO; fw->query_interval = ndctl_cmd_fw_info_get_query_interval(cmd); if (fw->query_interval == UINT_MAX) return -ENXIO; fw->max_query = ndctl_cmd_fw_info_get_max_query_time(cmd); if (fw->max_query == UINT_MAX) return -ENXIO; fw->run_version = ndctl_cmd_fw_info_get_run_version(cmd); if (fw->run_version == ULLONG_MAX) return -ENXIO; rc = verify_fw_size(uctx); ndctl_cmd_unref(cmd); return rc; } static int submit_start_firmware_upload(struct ndctl_dimm *dimm, struct action_context *actx) { struct update_context *uctx = &actx->update; struct fw_info *fw = &uctx->dimm_fw; struct ndctl_cmd *cmd; int rc; enum ND_FW_STATUS status; cmd = ndctl_dimm_cmd_new_fw_start_update(dimm); if (!cmd) return -ENXIO; rc = ndctl_cmd_submit(cmd); if (rc < 0) return rc; status = ndctl_cmd_fw_xlat_firmware_status(cmd); if (status != FW_SUCCESS) { fprintf(stderr, "START FIRMWARE UPDATE on DIMM %s failed: %#x\n", ndctl_dimm_get_devname(dimm), status); if (status == FW_EBUSY) fprintf(stderr, "Another firmware upload in progress" " or firmware already updated.\n"); return -ENXIO; } fw->context = ndctl_cmd_fw_start_get_context(cmd); if (fw->context == UINT_MAX) { fprintf(stderr, "Retrieved firmware context invalid on DIMM %s\n", ndctl_dimm_get_devname(dimm)); return -ENXIO; } uctx->start = cmd; return 0; } static int get_fw_data_from_file(FILE *file, void *buf, uint32_t len) { size_t rc; rc = fread(buf, len, 1, file); if (rc != 1) { if (feof(file)) fprintf(stderr, "Firmware file shorter than expected\n"); else if (ferror(file)) fprintf(stderr, "Firmware file read error\n"); return -EBADF; } return len; } static int send_firmware(struct ndctl_dimm *dimm, struct action_context *actx) { struct update_context *uctx = &actx->update; struct fw_info *fw = &uctx->dimm_fw; struct ndctl_cmd *cmd = NULL; ssize_t read; int rc = -ENXIO; enum ND_FW_STATUS status; uint32_t copied = 0, len, remain; void *buf; buf = malloc(fw->update_size); if (!buf) return -ENOMEM; remain = uctx->fw_size; while (remain) { len = min(fw->update_size, remain); read = get_fw_data_from_file(actx->f_in, buf, len); if (read < 0) { rc = read; goto cleanup; } cmd = ndctl_dimm_cmd_new_fw_send(uctx->start, copied, read, buf); if (!cmd) { rc = -ENXIO; goto cleanup; } rc = ndctl_cmd_submit(cmd); if (rc < 0) goto cleanup; status = ndctl_cmd_fw_xlat_firmware_status(cmd); if (status != FW_SUCCESS) { error("SEND FIRMWARE failed: %#x\n", status); rc = -ENXIO; goto cleanup; } copied += read; remain -= read; ndctl_cmd_unref(cmd); cmd = NULL; } cleanup: ndctl_cmd_unref(cmd); free(buf); return rc; } static int submit_finish_firmware(struct ndctl_dimm *dimm, struct action_context *actx) { struct update_context *uctx = &actx->update; struct ndctl_cmd *cmd; int rc; enum ND_FW_STATUS status; cmd = ndctl_dimm_cmd_new_fw_finish(uctx->start); if (!cmd) return -ENXIO; rc = ndctl_cmd_submit(cmd); if (rc < 0) goto out; status = ndctl_cmd_fw_xlat_firmware_status(cmd); if (status != FW_SUCCESS) { fprintf(stderr, "FINISH FIRMWARE UPDATE on DIMM %s failed: %#x\n", ndctl_dimm_get_devname(dimm), status); rc = -ENXIO; goto out; } out: ndctl_cmd_unref(cmd); return rc; } static int submit_abort_firmware(struct ndctl_dimm *dimm, struct action_context *actx) { struct update_context *uctx = &actx->update; struct ndctl_cmd *cmd; int rc; enum ND_FW_STATUS status; cmd = ndctl_dimm_cmd_new_fw_abort(uctx->start); if (!cmd) return -ENXIO; rc = ndctl_cmd_submit(cmd); if (rc < 0) goto out; status = ndctl_cmd_fw_xlat_firmware_status(cmd); if (!(status & ND_CMD_STATUS_FIN_ABORTED)) { fprintf(stderr, "Firmware update abort on DIMM %s failed: %#x\n", ndctl_dimm_get_devname(dimm), status); rc = -ENXIO; goto out; } out: ndctl_cmd_unref(cmd); return rc; } static int query_fw_finish_status(struct ndctl_dimm *dimm, struct action_context *actx) { struct update_context *uctx = &actx->update; struct fw_info *fw = &uctx->dimm_fw; struct ndctl_cmd *cmd; int rc; enum ND_FW_STATUS status; bool done = false; struct timespec now, before, after; uint64_t ver; cmd = ndctl_dimm_cmd_new_fw_finish_query(uctx->start); if (!cmd) return -ENXIO; rc = clock_gettime(CLOCK_MONOTONIC, &before); if (rc < 0) goto out; now.tv_nsec = fw->query_interval / 1000; now.tv_sec = 0; do { rc = ndctl_cmd_submit(cmd); if (rc < 0) break; status = ndctl_cmd_fw_xlat_firmware_status(cmd); switch (status) { case FW_SUCCESS: ver = ndctl_cmd_fw_fquery_get_fw_rev(cmd); if (ver == 0) { fprintf(stderr, "No firmware updated.\n"); rc = -ENXIO; goto out; } printf("Image updated successfully to DIMM %s.\n", ndctl_dimm_get_devname(dimm)); printf("Firmware version %#lx.\n", ver); printf("Cold reboot to activate.\n"); done = true; rc = 0; break; case FW_EBUSY: /* Still on going, continue */ rc = clock_gettime(CLOCK_MONOTONIC, &after); if (rc < 0) { rc = -errno; goto out; } /* * If we expire max query time, * we timed out */ if (after.tv_sec - before.tv_sec > fw->max_query / 1000000) { rc = -ETIMEDOUT; goto out; } /* * Sleep the interval dictated by firmware * before query again. */ rc = nanosleep(&now, NULL); if (rc < 0) { rc = -errno; goto out; } break; case FW_EBADFW: fprintf(stderr, "Firmware failed to verify by DIMM %s.\n", ndctl_dimm_get_devname(dimm)); case FW_EINVAL_CTX: case FW_ESEQUENCE: done = true; rc = -ENXIO; goto out; case FW_ENORES: fprintf(stderr, "Firmware update sequence timed out: %s\n", ndctl_dimm_get_devname(dimm)); rc = -ETIMEDOUT; done = true; goto out; default: fprintf(stderr, "Unknown update status: %#x on DIMM %s\n", status, ndctl_dimm_get_devname(dimm)); rc = -EINVAL; done = true; goto out; } } while (!done); out: ndctl_cmd_unref(cmd); return rc; } static int update_firmware(struct ndctl_dimm *dimm, struct action_context *actx) { int rc; rc = submit_get_firmware_info(dimm, actx); if (rc < 0) return rc; rc = submit_start_firmware_upload(dimm, actx); if (rc < 0) return rc; printf("Uploading firmware to DIMM %s.\n", ndctl_dimm_get_devname(dimm)); rc = send_firmware(dimm, actx); if (rc < 0) { fprintf(stderr, "Firmware send failed. Aborting!\n"); rc = submit_abort_firmware(dimm, actx); if (rc < 0) fprintf(stderr, "Aborting update sequence failed.\n"); return rc; } /* * Done reading file, reset firmware file back to beginning for * next update. */ rewind(actx->f_in); rc = submit_finish_firmware(dimm, actx); if (rc < 0) { fprintf(stderr, "Unable to end update sequence.\n"); rc = submit_abort_firmware(dimm, actx); if (rc < 0) fprintf(stderr, "Aborting update sequence failed.\n"); return rc; } rc = query_fw_finish_status(dimm, actx); if (rc < 0) return rc; return 0; } static int action_update(struct ndctl_dimm *dimm, struct action_context *actx) { int rc; rc = ndctl_dimm_fw_update_supported(dimm); switch (rc) { case -ENOTTY: error("%s: firmware update not supported by ndctl.", ndctl_dimm_get_devname(dimm)); return rc; case -EOPNOTSUPP: error("%s: firmware update not supported by the kernel", ndctl_dimm_get_devname(dimm)); return rc; case -EIO: error("%s: firmware update not supported by either platform firmware or the kernel.", ndctl_dimm_get_devname(dimm)); return rc; } rc = update_verify_input(actx); if (rc < 0) return rc; rc = update_firmware(dimm, actx); if (rc < 0) return rc; ndctl_cmd_unref(actx->update.start); return rc; } static struct parameters { const char *bus; const char *outfile; const char *infile; const char *labelversion; bool force; bool json; bool verbose; } param = { .labelversion = "1.1", }; static int __action_init(struct ndctl_dimm *dimm, enum ndctl_namespace_version version, int chk_only) { struct ndctl_cmd *cmd_read; int rc; cmd_read = ndctl_dimm_read_labels(dimm); if (!cmd_read) return -ENXIO; /* * If the region goes active after this point, i.e. we're racing * another administrative action, the kernel will fail writes to * the label area. */ if (!chk_only && ndctl_dimm_is_active(dimm)) { fprintf(stderr, "%s: regions active, abort label write\n", ndctl_dimm_get_devname(dimm)); rc = -EBUSY; goto out; } rc = ndctl_dimm_validate_labels(dimm); if (chk_only) goto out; if (rc >= 0 && !param.force) { fprintf(stderr, "%s: error: labels already initialized\n", ndctl_dimm_get_devname(dimm)); rc = -EBUSY; goto out; } rc = ndctl_dimm_init_labels(dimm, version); if (rc < 0) goto out; /* * If the dimm is already disabled the kernel is not holding a cached * copy of the label space. */ if (!ndctl_dimm_is_enabled(dimm)) goto out; rc = ndctl_dimm_disable(dimm); if (rc) goto out; rc = ndctl_dimm_enable(dimm); out: ndctl_cmd_unref(cmd_read); return rc; } static int action_init(struct ndctl_dimm *dimm, struct action_context *actx) { return __action_init(dimm, actx->labelversion, 0); } static int action_check(struct ndctl_dimm *dimm, struct action_context *actx) { return __action_init(dimm, 0, 1); } #define BASE_OPTIONS() \ OPT_STRING('b', "bus", ¶m.bus, "bus-id", \ " must be on a bus with an id/provider of "), \ OPT_BOOLEAN('v',"verbose", ¶m.verbose, "turn on debug") #define READ_OPTIONS() \ OPT_STRING('o', "output", ¶m.outfile, "output-file", \ "filename to write label area contents"), \ OPT_BOOLEAN('j', "json", ¶m.json, "parse label data into json") #define WRITE_OPTIONS() \ OPT_STRING('i', "input", ¶m.infile, "input-file", \ "filename to read label area data") #define UPDATE_OPTIONS() \ OPT_STRING('f', "firmware", ¶m.infile, "firmware-file", \ "firmware filename for update") #define INIT_OPTIONS() \ OPT_BOOLEAN('f', "force", ¶m.force, \ "force initialization even if existing index-block present"), \ OPT_STRING('V', "label-version", ¶m.labelversion, "version-number", \ "namespace label specification version (default: 1.1)") static const struct option read_options[] = { BASE_OPTIONS(), READ_OPTIONS(), OPT_END(), }; static const struct option write_options[] = { BASE_OPTIONS(), WRITE_OPTIONS(), OPT_END(), }; static const struct option update_options[] = { BASE_OPTIONS(), UPDATE_OPTIONS(), OPT_END(), }; static const struct option base_options[] = { BASE_OPTIONS(), OPT_END(), }; static const struct option init_options[] = { BASE_OPTIONS(), INIT_OPTIONS(), OPT_END(), }; static int dimm_action(int argc, const char **argv, void *ctx, int (*action)(struct ndctl_dimm *dimm, struct action_context *actx), const struct option *options, const char *usage) { struct action_context actx = { 0 }; int i, rc = 0, count = 0, err = 0; struct ndctl_dimm *single = NULL; const char * const u[] = { usage, NULL }; unsigned long id; argc = parse_options(argc, argv, options, u, 0); if (argc == 0) usage_with_options(u, options); for (i = 0; i < argc; i++) { if (strcmp(argv[i], "all") == 0) { argv[0] = "all"; argc = 1; break; } if (sscanf(argv[i], "nmem%lu", &id) != 1) { fprintf(stderr, "'%s' is not a valid dimm name\n", argv[i]); err++; } } if (err == argc) { usage_with_options(u, options); return -EINVAL; } if (param.json) { actx.jdimms = json_object_new_array(); if (!actx.jdimms) return -ENOMEM; } if (!param.outfile) actx.f_out = stdout; else { actx.f_out = fopen(param.outfile, "w+"); if (!actx.f_out) { fprintf(stderr, "failed to open: %s: (%s)\n", param.outfile, strerror(errno)); rc = -errno; goto out; } } if (!param.infile) { if (action == action_update) { usage_with_options(u, options); return -EINVAL; } actx.f_in = stdin; } else { actx.f_in = fopen(param.infile, "r"); if (!actx.f_in) { fprintf(stderr, "failed to open: %s: (%s)\n", param.infile, strerror(errno)); rc = -errno; goto out; } } if (param.verbose) ndctl_set_log_priority(ctx, LOG_DEBUG); if (strcmp(param.labelversion, "1.1") == 0) actx.labelversion = NDCTL_NS_VERSION_1_1; else if (strcmp(param.labelversion, "v1.1") == 0) actx.labelversion = NDCTL_NS_VERSION_1_1; else if (strcmp(param.labelversion, "1.2") == 0) actx.labelversion = NDCTL_NS_VERSION_1_2; else if (strcmp(param.labelversion, "v1.2") == 0) actx.labelversion = NDCTL_NS_VERSION_1_2; else { fprintf(stderr, "'%s' is not a valid label version\n", param.labelversion); rc = -EINVAL; goto out; } rc = 0; err = 0; count = 0; for (i = 0; i < argc; i++) { struct ndctl_dimm *dimm; struct ndctl_bus *bus; if (sscanf(argv[i], "nmem%lu", &id) != 1 && strcmp(argv[i], "all") != 0) continue; ndctl_bus_foreach(ctx, bus) { if (!util_bus_filter(bus, param.bus)) continue; ndctl_dimm_foreach(bus, dimm) { if (!util_dimm_filter(dimm, argv[i])) continue; if (action == action_write) { single = dimm; rc = 0; } else rc = action(dimm, &actx); if (rc == 0) count++; else if (rc && !err) err = rc; } } } rc = err; if (action == action_write) { if (count > 1) { error("write-labels only supports writing a single dimm\n"); usage_with_options(u, options); return -EINVAL; } else if (single) rc = action(single, &actx); } if (actx.jdimms) util_display_json_array(actx.f_out, actx.jdimms, JSON_C_TO_STRING_PRETTY); if (actx.f_out != stdout) fclose(actx.f_out); if (actx.f_in != stdin) fclose(actx.f_in); out: /* * count if some actions succeeded, 0 if none were attempted, * negative error code otherwise. */ if (count > 0) return count; return rc; } int cmd_write_labels(int argc, const char **argv, void *ctx) { int count = dimm_action(argc, argv, ctx, action_write, write_options, "ndctl write-labels [-i ]"); fprintf(stderr, "wrote %d nmem%s\n", count >= 0 ? count : 0, count > 1 ? "s" : ""); return count >= 0 ? 0 : EXIT_FAILURE; } int cmd_read_labels(int argc, const char **argv, void *ctx) { int count = dimm_action(argc, argv, ctx, action_read, read_options, "ndctl read-labels [..] [-o ]"); fprintf(stderr, "read %d nmem%s\n", count >= 0 ? count : 0, count > 1 ? "s" : ""); return count >= 0 ? 0 : EXIT_FAILURE; } int cmd_zero_labels(int argc, const char **argv, void *ctx) { int count = dimm_action(argc, argv, ctx, action_zero, base_options, "ndctl zero-labels [..] []"); fprintf(stderr, "zeroed %d nmem%s\n", count >= 0 ? count : 0, count > 1 ? "s" : ""); return count >= 0 ? 0 : EXIT_FAILURE; } int cmd_init_labels(int argc, const char **argv, void *ctx) { int count = dimm_action(argc, argv, ctx, action_init, init_options, "ndctl init-labels [..] []"); fprintf(stderr, "initialized %d nmem%s\n", count >= 0 ? count : 0, count > 1 ? "s" : ""); return count >= 0 ? 0 : EXIT_FAILURE; } int cmd_check_labels(int argc, const char **argv, void *ctx) { int count = dimm_action(argc, argv, ctx, action_check, base_options, "ndctl check-labels [..] []"); fprintf(stderr, "successfully verified %d nmem%s\n", count >= 0 ? count : 0, count > 1 ? "s" : ""); return count >= 0 ? 0 : EXIT_FAILURE; } int cmd_disable_dimm(int argc, const char **argv, void *ctx) { int count = dimm_action(argc, argv, ctx, action_disable, base_options, "ndctl disable-dimm [..] []"); fprintf(stderr, "disabled %d nmem%s\n", count >= 0 ? count : 0, count > 1 ? "s" : ""); return count >= 0 ? 0 : EXIT_FAILURE; } int cmd_enable_dimm(int argc, const char **argv, void *ctx) { int count = dimm_action(argc, argv, ctx, action_enable, base_options, "ndctl enable-dimm [..] []"); fprintf(stderr, "enabled %d nmem%s\n", count >= 0 ? count : 0, count > 1 ? "s" : ""); return count >= 0 ? 0 : EXIT_FAILURE; } int cmd_update_firmware(int argc, const char **argv, void *ctx) { int count = dimm_action(argc, argv, ctx, action_update, update_options, "ndctl update-firmware [..] []"); fprintf(stderr, "updated %d nmem%s.\n", count >= 0 ? count : 0, count > 1 ? "s" : ""); return count >= 0 ? 0 : EXIT_FAILURE; } ndctl-61.2/ndctl/firmware-update.h000066400000000000000000000022551331777607200171400ustar00rootroot00000000000000/* SPDX-License-Identifier: GPL-2.0 */ /* Copyright(c) 2018 Intel Corporation. All rights reserved. */ #ifndef _FIRMWARE_UPDATE_H_ #define _FIRMWARE_UPDATE_H_ #define ND_CMD_STATUS_SUCCESS 0 #define ND_CMD_STATUS_NOTSUPP 1 #define ND_CMD_STATUS_NOTEXIST 2 #define ND_CMD_STATUS_INVALPARM 3 #define ND_CMD_STATUS_HWERR 4 #define ND_CMD_STATUS_RETRY 5 #define ND_CMD_STATUS_UNKNOWN 6 #define ND_CMD_STATUS_EXTEND 7 #define ND_CMD_STATUS_NORES 8 #define ND_CMD_STATUS_NOTREADY 9 /* extended status through ND_CMD_STATUS_EXTEND */ #define ND_CMD_STATUS_START_BUSY 0x10000 #define ND_CMD_STATUS_SEND_CTXINVAL 0x10000 #define ND_CMD_STATUS_FIN_CTXINVAL 0x10000 #define ND_CMD_STATUS_FIN_DONE 0x20000 #define ND_CMD_STATUS_FIN_BAD 0x30000 #define ND_CMD_STATUS_FIN_ABORTED 0x40000 #define ND_CMD_STATUS_FQ_CTXINVAL 0x10000 #define ND_CMD_STATUS_FQ_BUSY 0x20000 #define ND_CMD_STATUS_FQ_BAD 0x30000 #define ND_CMD_STATUS_FQ_ORDER 0x40000 struct fw_info { uint32_t store_size; uint32_t update_size; uint32_t query_interval; uint32_t max_query; uint64_t run_version; uint32_t context; }; struct update_context { size_t fw_size; struct fw_info dimm_fw; struct ndctl_cmd *start; }; #endif ndctl-61.2/ndctl/inject-error.c000066400000000000000000000222351331777607200164420ustar00rootroot00000000000000/* * Copyright(c) 2015-2017 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify it * under the terms of version 2 of the GNU General Public License as * published by the Free Software Foundation. * * 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 * General Public License for more details. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "private.h" #include #include static bool verbose; static struct parameters { const char *bus; const char *region; const char *namespace; const char *block; const char *count; bool clear; bool status; bool no_notify; bool saturate; bool human; } param; static struct inject_ctx { u64 block; u64 count; unsigned int op_mask; unsigned long json_flags; unsigned int inject_flags; } ictx; #define BASE_OPTIONS() \ OPT_STRING('b', "bus", ¶m.bus, "bus-id", \ "limit namespace to a bus with an id or provider of "), \ OPT_STRING('r', "region", ¶m.region, "region-id", \ "limit namespace to a region with an id or name of "), \ OPT_BOOLEAN('v', "verbose", &verbose, "emit extra debug messages to stderr") #define INJECT_OPTIONS() \ OPT_STRING('B', "block", ¶m.block, "namespace block offset (512B)", \ "specify the block at which to (un)inject the error"), \ OPT_STRING('n', "count", ¶m.count, "count", \ "specify the number of blocks of errors to (un)inject"), \ OPT_BOOLEAN('d', "uninject", ¶m.clear, \ "un-inject a previously injected error"), \ OPT_BOOLEAN('t', "status", ¶m.status, "get error injection status"), \ OPT_BOOLEAN('N', "no-notify", ¶m.no_notify, "firmware should not notify OS"), \ OPT_BOOLEAN('S', "saturate", ¶m.saturate, \ "inject full sector, not just 'ars_unit' bytes"), \ OPT_BOOLEAN('u', "human", ¶m.human, "use human friendly number formats ") static const struct option inject_options[] = { BASE_OPTIONS(), INJECT_OPTIONS(), OPT_END(), }; enum { OP_INJECT = 0, OP_CLEAR, OP_STATUS, }; static int inject_init(void) { if (!param.clear && !param.status) { ictx.op_mask |= 1 << OP_INJECT; ictx.inject_flags |= (1 << NDCTL_NS_INJECT_NOTIFY); if (param.no_notify) ictx.inject_flags &= ~(1 << NDCTL_NS_INJECT_NOTIFY); } if (param.clear) { if (param.status) { error("status is invalid with inject or uninject\n"); return -EINVAL; } ictx.op_mask |= 1 << OP_CLEAR; } if (param.status) { if (param.block || param.count || param.saturate) { error("status is invalid with inject or uninject\n"); return -EINVAL; } ictx.op_mask |= 1 << OP_STATUS; } if (ictx.op_mask == 0) { error("Unable to determine operation\n"); return -EINVAL; } ictx.op_mask &= ( (1 << OP_INJECT) | (1 << OP_CLEAR) | (1 << OP_STATUS)); if (param.block) { ictx.block = parse_size64(param.block); if (ictx.block == ULLONG_MAX) { error("Invalid block: %s\n", param.block); return -EINVAL; } } if (param.count) { ictx.count = parse_size64(param.count); if (ictx.count == ULLONG_MAX) { error("Invalid count: %s\n", param.count); return -EINVAL; } } /* For inject or clear, an block and count are required */ if (ictx.op_mask & ((1 << OP_INJECT) | (1 << OP_CLEAR))) { if (!param.block || !param.count) { error("block and count required for inject/uninject\n"); return -EINVAL; } } if (param.human) ictx.json_flags |= UTIL_JSON_HUMAN; if (param.saturate) ictx.inject_flags |= 1 << NDCTL_NS_INJECT_SATURATE; return 0; } static int ns_errors_to_json(struct ndctl_namespace *ndns, unsigned int start_count) { unsigned long json_flags = ictx.json_flags | UTIL_JSON_MEDIA_ERRORS; struct ndctl_bus *bus = ndctl_namespace_get_bus(ndns); struct json_object *jndns; unsigned int count; int rc, tmo = 30; /* only wait for scrubs for the inject and notify case */ if ((ictx.op_mask & (1 << OP_INJECT)) && (ictx.inject_flags & (1 << NDCTL_NS_INJECT_NOTIFY))) { do { /* wait for a scrub to start */ count = ndctl_bus_get_scrub_count(bus); if (count == UINT_MAX) { fprintf(stderr, "Unable to get scrub count\n"); return -ENXIO; } sleep(1); } while (count <= start_count && --tmo > 0); rc = ndctl_bus_wait_for_scrub_completion(bus); if (rc) { fprintf(stderr, "Error waiting for scrub\n"); return rc; } } jndns = util_namespace_to_json(ndns, json_flags); if (jndns) printf("%s\n", json_object_to_json_string_ext(jndns, JSON_C_TO_STRING_PRETTY)); return 0; } static int inject_error(struct ndctl_namespace *ndns, u64 offset, u64 length, unsigned int flags) { struct ndctl_bus *bus = ndctl_namespace_get_bus(ndns); unsigned int scrub_count; int rc; scrub_count = ndctl_bus_get_scrub_count(bus); if (scrub_count == UINT_MAX) { fprintf(stderr, "Unable to get scrub count\n"); return -ENXIO; } rc = ndctl_namespace_inject_error2(ndns, offset, length, flags); if (rc) { fprintf(stderr, "Unable to inject error: %s (%d)\n", strerror(abs(rc)), rc); return rc; } return ns_errors_to_json(ndns, scrub_count); } static int uninject_error(struct ndctl_namespace *ndns, u64 offset, u64 length, unsigned int flags) { int rc; rc = ndctl_namespace_uninject_error2(ndns, offset, length, flags); if (rc) { fprintf(stderr, "Unable to uninject error: %s (%d)\n", strerror(abs(rc)), rc); return rc; } printf("Warning: Un-injecting previously injected errors here will\n"); printf("not cause the kernel to 'forget' its badblock entries. Those\n"); printf("have to be cleared through the normal process of writing\n"); printf("the affected blocks\n\n"); return ns_errors_to_json(ndns, 0); } static int injection_status(struct ndctl_namespace *ndns) { unsigned long long block, count, bbs = 0; struct json_object *jbbs, *jbb, *jobj; struct ndctl_bb *bb; int rc; rc = ndctl_namespace_injection_status(ndns); if (rc) { fprintf(stderr, "Unable to get injection status: %s (%d)\n", strerror(abs(rc)), rc); return rc; } jobj = json_object_new_object(); if (!jobj) return -ENOMEM; jbbs = json_object_new_array(); if (!jbbs) { json_object_put(jobj); return -ENOMEM; } ndctl_namespace_bb_foreach(ndns, bb) { if (!bb) break; block = ndctl_bb_get_block(bb); count = ndctl_bb_get_count(bb); jbb = util_badblock_rec_to_json(block, count, ictx.json_flags); if (!jbb) break; json_object_array_add(jbbs, jbb); bbs++; } if (bbs) { json_object_object_add(jobj, "badblocks", jbbs); printf("%s\n", json_object_to_json_string_ext(jobj, JSON_C_TO_STRING_PRETTY)); } json_object_put(jobj); return rc; } static int err_inject_ns(struct ndctl_namespace *ndns) { unsigned int op_mask; int rc; op_mask = ictx.op_mask; while (op_mask) { if (op_mask & (1 << OP_INJECT)) { rc = inject_error(ndns, ictx.block, ictx.count, ictx.inject_flags); if (rc) return rc; op_mask &= ~(1 << OP_INJECT); } if (op_mask & (1 << OP_CLEAR)) { rc = uninject_error(ndns, ictx.block, ictx.count, ictx.inject_flags); if (rc) return rc; op_mask &= ~(1 << OP_CLEAR); } if (op_mask & (1 << OP_STATUS)) { rc = injection_status(ndns); if (rc) return rc; op_mask &= ~(1 << OP_STATUS); } } return rc; } static int do_inject(const char *namespace, struct ndctl_ctx *ctx) { struct ndctl_namespace *ndns; struct ndctl_region *region; const char *ndns_name; struct ndctl_bus *bus; int rc = -ENXIO; if (namespace == NULL) return rc; if (verbose) ndctl_set_log_priority(ctx, LOG_DEBUG); ndctl_bus_foreach(ctx, bus) { if (!util_bus_filter(bus, param.bus)) continue; ndctl_region_foreach(bus, region) { if (!util_region_filter(region, param.region)) continue; ndctl_namespace_foreach(region, ndns) { ndns_name = ndctl_namespace_get_devname(ndns); if (strcmp(namespace, ndns_name) != 0) continue; if (!ndctl_bus_has_error_injection(bus)) { fprintf(stderr, "%s: error injection not supported\n", ndns_name); return -EOPNOTSUPP; } return err_inject_ns(ndns); } } } error("%s: no such namespace\n", namespace); return rc; } int cmd_inject_error(int argc, const char **argv, void *ctx) { const char * const u[] = { "ndctl inject-error []", NULL }; int i, rc; argc = parse_options(argc, argv, inject_options, u, 0); rc = inject_init(); if (rc) return rc; if (argc == 0) error("specify a namespace to inject error to\n"); for (i = 1; i < argc; i++) error("unknown extra parameter \"%s\"\n", argv[i]); if (argc == 0 || argc > 1) { usage_with_options(u, inject_options); return -ENODEV; /* we won't return from usage_with_options() */ } return do_inject(argv[0], ctx); } ndctl-61.2/ndctl/inject-smart.c000066400000000000000000000257041331777607200164430ustar00rootroot00000000000000/* SPDX-License-Identifier: GPL-2.0 */ /* Copyright(c) 2018 Intel Corporation. All rights reserved. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "private.h" #include #include static struct parameters { const char *bus; const char *dimm; bool verbose; bool human; const char *media_temperature; const char *ctrl_temperature; const char *spares; const char *media_temperature_threshold; const char *ctrl_temperature_threshold; const char *spares_threshold; const char *media_temperature_alarm; const char *ctrl_temperature_alarm; const char *spares_alarm; bool fatal; bool unsafe_shutdown; } param; static struct smart_ctx { bool alarms_present; unsigned long op_mask; unsigned long flags; unsigned int media_temperature; unsigned int ctrl_temperature; unsigned long spares; unsigned int media_temperature_threshold; unsigned int ctrl_temperature_threshold; unsigned long spares_threshold; unsigned int media_temperature_alarm; unsigned int ctrl_temperature_alarm; unsigned long spares_alarm; } sctx; #define SMART_OPTIONS() \ OPT_STRING('b', "bus", ¶m.bus, "bus-id", \ "limit dimm to a bus with an id or provider of "), \ OPT_BOOLEAN('v', "verbose", ¶m.verbose, "emit extra debug messages to stderr"), \ OPT_BOOLEAN('u', "human", ¶m.human, "use human friendly number formats"), \ OPT_STRING('m', "media-temperature", ¶m.media_temperature, \ "smart media temperature attribute", \ "inject a value for smart media temperature"), \ OPT_STRING('M', "media-temperature-threshold", \ ¶m.media_temperature_threshold, \ "set smart media temperature threshold", \ "set threshold value for smart media temperature"), \ OPT_STRING('x', "media-temperature-alarm", ¶m.media_temperature_alarm, \ "smart media temperature alarm", \ "enable or disable the smart media temperature alarm"), \ OPT_STRING('c', "ctrl-temperature", ¶m.ctrl_temperature, \ "smart controller temperature attribute", \ "inject a value for smart controller temperature"), \ OPT_STRING('C', "ctrl-temperature-threshold", \ ¶m.ctrl_temperature_threshold, \ "set smart controller temperature threshold", \ "set threshold value for smart controller temperature"), \ OPT_STRING('y', "ctrl-temperature-alarm", ¶m.ctrl_temperature_alarm, \ "smart controller temperature alarm", \ "enable or disable the smart controller temperature alarm"), \ OPT_STRING('s', "spares", ¶m.spares, \ "smart spares attribute", \ "inject a value for smart spares"), \ OPT_STRING('S', "spares-threshold", ¶m.spares_threshold, \ "set smart spares threshold", \ "set a threshold value for smart spares"), \ OPT_STRING('z', "spares-alarm", ¶m.spares_alarm, \ "smart spares alarm", \ "enable or disable the smart spares alarm"), \ OPT_BOOLEAN('f', "fatal", ¶m.fatal, "inject fatal smart health status"), \ OPT_BOOLEAN('U', "unsafe-shutdown", ¶m.unsafe_shutdown, \ "inject smart unsafe shutdown status") static const struct option smart_opts[] = { SMART_OPTIONS(), OPT_END(), }; enum smart_ops { OP_SET = 0, OP_INJECT, }; enum alarms { ALARM_ON = 1, ALARM_OFF, }; static inline void enable_set(void) { sctx.op_mask |= 1 << OP_SET; } static inline void enable_inject(void) { sctx.op_mask |= 1 << OP_INJECT; } #define smart_param_setup_uint(arg) \ { \ if (param.arg) { \ sctx.arg = strtoul(param.arg, NULL, 0); \ if (sctx.arg == ULONG_MAX || sctx.arg > UINT_MAX) { \ error("Invalid argument: %s: %s\n", #arg, param.arg); \ return -EINVAL; \ } \ enable_inject(); \ } \ if (param.arg##_threshold) { \ sctx.arg##_threshold = \ strtoul(param.arg##_threshold, NULL, 0); \ if (sctx.arg##_threshold == ULONG_MAX \ || sctx.arg##_threshold > UINT_MAX) { \ error("Invalid argument: %s\n", \ param.arg##_threshold); \ return -EINVAL; \ } \ enable_set(); \ } \ } #define smart_param_setup_temps(arg) \ { \ double temp; \ if (param.arg) { \ temp = strtod(param.arg, NULL); \ if (temp == HUGE_VAL || temp == -HUGE_VAL) { \ error("Invalid argument: %s: %s\n", #arg, param.arg); \ return -EINVAL; \ } \ sctx.arg = ndctl_encode_smart_temperature(temp); \ enable_inject(); \ } \ if (param.arg##_threshold) { \ temp = strtod(param.arg##_threshold, NULL); \ if (temp == HUGE_VAL || temp == -HUGE_VAL) { \ error("Invalid argument: %s\n", \ param.arg##_threshold); \ return -EINVAL; \ } \ sctx.arg##_threshold = ndctl_encode_smart_temperature(temp); \ enable_set(); \ } \ } #define smart_param_setup_alarm(arg) \ { \ if (param.arg##_alarm) { \ if (strncmp(param.arg##_alarm, "on", 2) == 0) \ sctx.arg##_alarm = ALARM_ON; \ else if (strncmp(param.arg##_alarm, "off", 3) == 0) \ sctx.arg##_alarm = ALARM_OFF; \ sctx.alarms_present = true; \ } \ } static int smart_init(void) { if (param.human) sctx.flags |= UTIL_JSON_HUMAN; /* setup attributes and thresholds except alarm_control */ smart_param_setup_temps(media_temperature) smart_param_setup_temps(ctrl_temperature) smart_param_setup_uint(spares) /* set up alarm_control */ smart_param_setup_alarm(media_temperature) smart_param_setup_alarm(ctrl_temperature) smart_param_setup_alarm(spares) if (sctx.alarms_present) enable_set(); /* setup remaining injection attributes */ if (param.fatal || param.unsafe_shutdown) enable_inject(); if (sctx.op_mask == 0) { error("No valid operation specified\n"); return -EINVAL; } return 0; } #define setup_thresh_field(arg) \ { \ if (param.arg##_threshold) \ ndctl_cmd_smart_threshold_set_##arg(sst_cmd, \ sctx.arg##_threshold); \ } static int smart_set_thresh(struct ndctl_dimm *dimm) { const char *name = ndctl_dimm_get_devname(dimm); struct ndctl_cmd *st_cmd = NULL, *sst_cmd = NULL; int rc = -EOPNOTSUPP; st_cmd = ndctl_dimm_cmd_new_smart_threshold(dimm); if (!st_cmd) { error("%s: no smart threshold command support\n", name); goto out; } rc = ndctl_cmd_submit(st_cmd); if (rc) { error("%s: smart threshold command failed: %s (%d)\n", name, strerror(abs(rc)), rc); goto out; } sst_cmd = ndctl_dimm_cmd_new_smart_set_threshold(st_cmd); if (!sst_cmd) { error("%s: no smart set threshold command support\n", name); rc = -EOPNOTSUPP; goto out; } /* setup all thresholds except alarm_control */ setup_thresh_field(media_temperature) setup_thresh_field(ctrl_temperature) setup_thresh_field(spares) /* setup alarm_control manually */ if (sctx.alarms_present) { unsigned int alarm; alarm = ndctl_cmd_smart_threshold_get_alarm_control(st_cmd); if (sctx.media_temperature_alarm == ALARM_ON) alarm |= ND_SMART_TEMP_TRIP; else if (sctx.media_temperature_alarm == ALARM_OFF) alarm &= ~ND_SMART_TEMP_TRIP; if (sctx.ctrl_temperature_alarm == ALARM_ON) alarm |= ND_SMART_CTEMP_TRIP; else if (sctx.ctrl_temperature_alarm == ALARM_OFF) alarm &= ~ND_SMART_CTEMP_TRIP; if (sctx.spares_alarm == ALARM_ON) alarm |= ND_SMART_SPARE_TRIP; else if (sctx.spares_alarm == ALARM_OFF) alarm &= ~ND_SMART_SPARE_TRIP; ndctl_cmd_smart_threshold_set_alarm_control(sst_cmd, alarm); } rc = ndctl_cmd_submit(sst_cmd); if (rc) error("%s: smart set threshold command failed: %s (%d)\n", name, strerror(abs(rc)), rc); out: ndctl_cmd_unref(sst_cmd); ndctl_cmd_unref(st_cmd); return rc; } #define send_inject_val(arg) \ { \ if (param.arg) { \ si_cmd = ndctl_dimm_cmd_new_smart_inject(dimm); \ if (!si_cmd) { \ error("%s: no smart inject command support\n", name); \ goto out; \ } \ rc = ndctl_cmd_smart_inject_##arg(si_cmd, true, sctx.arg); \ if (rc) { \ error("%s: smart inject %s cmd invalid: %s (%d)\n", \ name, #arg, strerror(abs(rc)), rc); \ goto out; \ } \ rc = ndctl_cmd_submit(si_cmd); \ if (rc) { \ error("%s: smart inject %s command failed: %s (%d)\n", \ name, #arg, strerror(abs(rc)), rc); \ goto out; \ } \ ndctl_cmd_unref(si_cmd); \ } \ } #define send_inject_bool(arg) \ { \ if (param.arg) { \ si_cmd = ndctl_dimm_cmd_new_smart_inject(dimm); \ if (!si_cmd) { \ error("%s: no smart inject command support\n", name); \ goto out; \ } \ rc = ndctl_cmd_smart_inject_##arg(si_cmd, true); \ if (rc) { \ error("%s: smart inject %s cmd invalid: %s (%d)\n", \ name, #arg, strerror(abs(rc)), rc); \ goto out; \ } \ rc = ndctl_cmd_submit(si_cmd); \ if (rc) { \ error("%s: smart inject %s command failed: %s (%d)\n", \ name, #arg, strerror(abs(rc)), rc); \ goto out; \ } \ ndctl_cmd_unref(si_cmd); \ } \ } static int smart_inject(struct ndctl_dimm *dimm) { const char *name = ndctl_dimm_get_devname(dimm); struct ndctl_cmd *si_cmd = NULL; int rc = -EOPNOTSUPP; send_inject_val(media_temperature) send_inject_val(spares) send_inject_bool(fatal) send_inject_bool(unsafe_shutdown) out: ndctl_cmd_unref(si_cmd); return rc; } static int dimm_inject_smart(struct ndctl_dimm *dimm) { struct json_object *jhealth; struct json_object *jdimms; struct json_object *jdimm; int rc; if (sctx.op_mask & (1 << OP_SET)) { rc = smart_set_thresh(dimm); if (rc) goto out; } if (sctx.op_mask & (1 << OP_INJECT)) { rc = smart_inject(dimm); if (rc) goto out; } if (rc == 0) { jdimms = json_object_new_array(); if (!jdimms) goto out; jdimm = util_dimm_to_json(dimm, sctx.flags); if (!jdimm) goto out; json_object_array_add(jdimms, jdimm); jhealth = util_dimm_health_to_json(dimm); if (jhealth) { json_object_object_add(jdimm, "health", jhealth); util_display_json_array(stdout, jdimms, JSON_C_TO_STRING_PRETTY); } } out: return rc; } static int do_smart(const char *dimm_arg, struct ndctl_ctx *ctx) { struct ndctl_dimm *dimm; struct ndctl_bus *bus; int rc = -ENXIO; if (dimm_arg == NULL) return rc; if (param.verbose) ndctl_set_log_priority(ctx, LOG_DEBUG); ndctl_bus_foreach(ctx, bus) { if (!util_bus_filter(bus, param.bus)) continue; ndctl_dimm_foreach(bus, dimm) { if (!util_dimm_filter(dimm, dimm_arg)) continue; return dimm_inject_smart(dimm); } } error("%s: no such dimm\n", dimm_arg); return rc; } int cmd_inject_smart(int argc, const char **argv, void *ctx) { const char * const u[] = { "ndctl inject-smart []", NULL }; int i, rc; argc = parse_options(argc, argv, smart_opts, u, 0); rc = smart_init(); if (rc) return rc; if (argc == 0) error("specify a dimm for the smart operation\n"); for (i = 1; i < argc; i++) error("unknown extra parameter \"%s\"\n", argv[i]); if (argc == 0 || argc > 1) { usage_with_options(u, smart_opts); return -ENODEV; /* we won't return from usage_with_options() */ } return do_smart(argv[0], ctx); } ndctl-61.2/ndctl/lib/000077500000000000000000000000001331777607200144355ustar00rootroot00000000000000ndctl-61.2/ndctl/lib/.gitignore000066400000000000000000000000701331777607200164220ustar00rootroot00000000000000.dirstamp .deps/ .libs/ *.la *.lo libabc.pc test-libabc ndctl-61.2/ndctl/lib/Makefile.am000066400000000000000000000015341331777607200164740ustar00rootroot00000000000000include $(top_srcdir)/Makefile.am.in %.pc: %.pc.in Makefile $(SED_PROCESS) pkginclude_HEADERS = ../libndctl.h ../ndctl.h lib_LTLIBRARIES = libndctl.la libndctl_la_SOURCES =\ libndctl.h \ private.h \ ../../util/log.c \ ../../util/log.h \ ../../util/sysfs.c \ ../../util/sysfs.h \ dimm.c \ inject.c \ nfit.c \ smart.c \ intel.c \ hpe1.c \ msft.c \ ars.c \ firmware.c \ libndctl.c libndctl_la_LIBADD =\ ../../daxctl/lib/libdaxctl.la \ $(UDEV_LIBS) \ $(UUID_LIBS) \ $(KMOD_LIBS) EXTRA_DIST += libndctl.sym libndctl_la_LDFLAGS = $(AM_LDFLAGS) \ -version-info $(LIBNDCTL_CURRENT):$(LIBNDCTL_REVISION):$(LIBNDCTL_AGE) \ -Wl,--version-script=$(top_srcdir)/ndctl/lib/libndctl.sym libndctl_la_DEPENDENCIES = libndctl.sym pkgconfigdir = $(libdir)/pkgconfig pkgconfig_DATA = libndctl.pc EXTRA_DIST += libndctl.pc.in CLEANFILES += libndctl.pc ndctl-61.2/ndctl/lib/ars.c000066400000000000000000000211311331777607200153640ustar00rootroot00000000000000/* * Copyright (c) 2014-2016, Intel Corporation. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU Lesser General Public License, * version 2.1, as published by the Free Software Foundation. * * This program is distributed in the hope 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. */ #include #include #include "private.h" NDCTL_EXPORT struct ndctl_cmd *ndctl_bus_cmd_new_ars_cap(struct ndctl_bus *bus, unsigned long long address, unsigned long long len) { struct ndctl_ctx *ctx = ndctl_bus_get_ctx(bus); struct ndctl_cmd *cmd; size_t size; if (!ndctl_bus_is_cmd_supported(bus, ND_CMD_ARS_CAP)) { dbg(ctx, "unsupported cmd\n"); return NULL; } size = sizeof(*cmd) + sizeof(struct nd_cmd_ars_cap); cmd = calloc(1, size); if (!cmd) return NULL; cmd->bus = bus; ndctl_cmd_ref(cmd); cmd->type = ND_CMD_ARS_CAP; cmd->size = size; cmd->status = 1; cmd->firmware_status = &cmd->ars_cap->status; cmd->ars_cap->address = address; cmd->ars_cap->length = len; return cmd; } static bool is_power_of_2(unsigned int v) { return v && ((v & (v - 1)) == 0); } static bool validate_clear_error(struct ndctl_cmd *ars_cap) { if (!is_power_of_2(ars_cap->ars_cap->clear_err_unit)) return false; return true; } static bool __validate_ars_cap(struct ndctl_cmd *ars_cap) { if (ars_cap->type != ND_CMD_ARS_CAP || ars_cap->status != 0) return false; if ((*ars_cap->firmware_status & ARS_STATUS_MASK) != 0) return false; return validate_clear_error(ars_cap); } #define validate_ars_cap(ctx, ars_cap) \ ({ \ bool __valid = __validate_ars_cap(ars_cap); \ if (!__valid) \ dbg(ctx, "expected sucessfully completed ars_cap command\n"); \ __valid; \ }) NDCTL_EXPORT struct ndctl_cmd *ndctl_bus_cmd_new_ars_start(struct ndctl_cmd *ars_cap, int type) { struct ndctl_bus *bus = ars_cap->bus; struct ndctl_ctx *ctx = ndctl_bus_get_ctx(bus); struct ndctl_cmd *cmd; size_t size; if (!ndctl_bus_is_cmd_supported(bus, ND_CMD_ARS_START)) { dbg(ctx, "unsupported cmd\n"); return NULL; } if (!validate_ars_cap(ctx, ars_cap)) return NULL; if (!(*ars_cap->firmware_status >> ARS_EXT_STATUS_SHIFT & type)) { dbg(ctx, "ars_cap does not show requested type as supported\n"); return NULL; } size = sizeof(*cmd) + sizeof(struct nd_cmd_ars_start); cmd = calloc(1, size); if (!cmd) return NULL; cmd->bus = bus; ndctl_cmd_ref(cmd); cmd->type = ND_CMD_ARS_START; cmd->size = size; cmd->status = 1; cmd->firmware_status = &cmd->ars_start->status; cmd->ars_start->address = ars_cap->ars_cap->address; cmd->ars_start->length = ars_cap->ars_cap->length; cmd->ars_start->type = type; return cmd; } NDCTL_EXPORT struct ndctl_cmd *ndctl_bus_cmd_new_ars_status(struct ndctl_cmd *ars_cap) { struct nd_cmd_ars_cap *ars_cap_cmd = ars_cap->ars_cap; struct ndctl_bus *bus = ars_cap->bus; struct ndctl_ctx *ctx = ndctl_bus_get_ctx(bus); struct ndctl_cmd *cmd; size_t size; if (!ndctl_bus_is_cmd_supported(bus, ND_CMD_ARS_STATUS)) { dbg(ctx, "unsupported cmd\n"); return NULL; } if (!validate_ars_cap(ctx, ars_cap)) return NULL; if (ars_cap_cmd->max_ars_out == 0) { dbg(ctx, "invalid ars_cap\n"); return NULL; } size = sizeof(*cmd) + ars_cap_cmd->max_ars_out; cmd = calloc(1, size); if (!cmd) return NULL; cmd->bus = bus; ndctl_cmd_ref(cmd); cmd->type = ND_CMD_ARS_STATUS; cmd->size = size; cmd->status = 1; cmd->firmware_status = &cmd->ars_status->status; cmd->ars_status->out_length = ars_cap_cmd->max_ars_out; return cmd; } NDCTL_EXPORT unsigned int ndctl_cmd_ars_cap_get_size(struct ndctl_cmd *ars_cap) { struct ndctl_ctx *ctx = ndctl_bus_get_ctx(cmd_to_bus(ars_cap)); if (ars_cap->type == ND_CMD_ARS_CAP && ars_cap->status == 0) { dbg(ctx, "max_ars_out: %d\n", ars_cap->ars_cap->max_ars_out); return ars_cap->ars_cap->max_ars_out; } dbg(ctx, "invalid ars_cap\n"); return 0; } NDCTL_EXPORT int ndctl_cmd_ars_cap_get_range(struct ndctl_cmd *ars_cap, struct ndctl_range *range) { struct ndctl_ctx *ctx = ndctl_bus_get_ctx(cmd_to_bus(ars_cap)); if (range && ars_cap->type == ND_CMD_ARS_CAP && ars_cap->status == 0) { struct nd_cmd_ars_cap *cap = ars_cap->ars_cap; dbg(ctx, "range: %llx - %llx\n", cap->address, cap->length); range->address = cap->address; range->length = cap->length; return 0; } dbg(ctx, "invalid ars_cap\n"); return -EINVAL; } NDCTL_EXPORT unsigned int ndctl_cmd_ars_cap_get_clear_unit( struct ndctl_cmd *ars_cap) { struct ndctl_ctx *ctx = ndctl_bus_get_ctx(cmd_to_bus(ars_cap)); if (ars_cap->type == ND_CMD_ARS_CAP && ars_cap->status == 0) { dbg(ctx, "clear_err_unit: %d\n", ars_cap->ars_cap->clear_err_unit); return ars_cap->ars_cap->clear_err_unit; } dbg(ctx, "invalid ars_cap\n"); return 0; } static bool __validate_ars_stat(struct ndctl_cmd *ars_stat) { /* * A positive status indicates an underrun, but that is fine since * the firmware is not expected to completely fill the max_ars_out * sized buffer. */ if (ars_stat->type != ND_CMD_ARS_STATUS || ars_stat->status < 0) return false; if ((ndctl_cmd_get_firmware_status(ars_stat) & ARS_STATUS_MASK) != 0) return false; return true; } #define validate_ars_stat(ctx, ars_stat) \ ({ \ bool __valid = __validate_ars_stat(ars_stat); \ if (!__valid) \ dbg(ctx, "expected sucessfully completed ars_stat command\n"); \ __valid; \ }) NDCTL_EXPORT int ndctl_cmd_ars_in_progress(struct ndctl_cmd *cmd) { struct ndctl_ctx *ctx = ndctl_bus_get_ctx(cmd_to_bus(cmd)); if (!validate_ars_stat(ctx, cmd)) return 0; return (ndctl_cmd_get_firmware_status(cmd) == 1 << 16); } NDCTL_EXPORT unsigned int ndctl_cmd_ars_num_records(struct ndctl_cmd *ars_stat) { struct ndctl_ctx *ctx = ndctl_bus_get_ctx(cmd_to_bus(ars_stat)); if (!validate_ars_stat(ctx, ars_stat)) return 0; return ars_stat->ars_status->num_records; } NDCTL_EXPORT unsigned long long ndctl_cmd_ars_get_record_addr( struct ndctl_cmd *ars_stat, unsigned int rec_index) { struct ndctl_ctx *ctx = ndctl_bus_get_ctx(cmd_to_bus(ars_stat)); if (!validate_ars_stat(ctx, ars_stat)) return 0; if (rec_index >= ars_stat->ars_status->num_records) { dbg(ctx, "invalid record index\n"); return 0; } return ars_stat->ars_status->records[rec_index].err_address; } NDCTL_EXPORT unsigned long long ndctl_cmd_ars_get_record_len( struct ndctl_cmd *ars_stat, unsigned int rec_index) { struct ndctl_ctx *ctx = ndctl_bus_get_ctx(cmd_to_bus(ars_stat)); if (!validate_ars_stat(ctx, ars_stat)) return 0; if (rec_index >= ars_stat->ars_status->num_records) { dbg(ctx, "invalid record index\n"); return 0; } return ars_stat->ars_status->records[rec_index].length; } NDCTL_EXPORT int ndctl_cmd_ars_stat_get_flag_overflow( struct ndctl_cmd *ars_stat) { struct ndctl_ctx *ctx = ndctl_bus_get_ctx(cmd_to_bus(ars_stat)); if (!validate_ars_stat(ctx, ars_stat)) return -EINVAL; return !!(ars_stat->ars_status->flags & ND_ARS_STAT_FLAG_OVERFLOW); } NDCTL_EXPORT struct ndctl_cmd *ndctl_bus_cmd_new_clear_error( unsigned long long address, unsigned long long len, struct ndctl_cmd *ars_cap) { size_t size; unsigned int mask; struct nd_cmd_ars_cap *cap; struct ndctl_cmd *clear_err; struct ndctl_bus *bus = ars_cap->bus; struct ndctl_ctx *ctx = ndctl_bus_get_ctx(bus); if (!ndctl_bus_is_cmd_supported(bus, ND_CMD_ARS_STATUS)) { dbg(ctx, "unsupported cmd\n"); return NULL; } if (!validate_ars_cap(ctx, ars_cap)) return NULL; cap = ars_cap->ars_cap; if (address < cap->address || address > (cap->address + cap->length) || address + len > (cap->address + cap->length)) { dbg(ctx, "request out of range (relative to ars_cap)\n"); return NULL; } mask = cap->clear_err_unit - 1; if ((address | len) & mask) { dbg(ctx, "request unaligned\n"); return NULL; } size = sizeof(*clear_err) + sizeof(struct nd_cmd_clear_error); clear_err = calloc(1, size); if (!clear_err) return NULL; ndctl_cmd_ref(clear_err); clear_err->bus = bus; clear_err->type = ND_CMD_CLEAR_ERROR; clear_err->size = size; clear_err->status = 1; clear_err->firmware_status = &clear_err->clear_err->status; clear_err->clear_err->address = address; clear_err->clear_err->length = len; return clear_err; } NDCTL_EXPORT unsigned long long ndctl_cmd_clear_error_get_cleared( struct ndctl_cmd *clear_err) { struct ndctl_ctx *ctx = ndctl_bus_get_ctx(cmd_to_bus(clear_err)); if (clear_err->type == ND_CMD_CLEAR_ERROR && clear_err->status == 0) return clear_err->clear_err->cleared; dbg(ctx, "invalid clear_err\n"); return 0; } ndctl-61.2/ndctl/lib/dimm.c000066400000000000000000000355521331777607200155410ustar00rootroot00000000000000/* * Copyright (c) 2014-2017, Intel Corporation. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU Lesser General Public License, * version 2.1, as published by the Free Software Foundation. * * This program is distributed in the hope 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. */ #include #include #include #include #include #include #include "private.h" static const char NSINDEX_SIGNATURE[] = "NAMESPACE_INDEX\0"; /* * Note, best_seq(), inc_seq(), sizeof_namespace_index() * nvdimm_num_label_slots(), label_validate(), and label_write_index() * are copied from drivers/nvdimm/label.c in the Linux kernel with the * following modifications: * 1/ s,nd_,,gc * 2/ s,ndd->nsarea.config_size,ndd->config_size,gc * 3/ s,dev_dbg(dev,dbg(ctx,gc * 4/ s,__le,le,gc * 5/ s,__cpu_to,cpu_to,gc * 6/ remove flags argument to label_write_index * 7/ dropped clear_bit_le() usage in label_write_index * 8/ s,nvdimm_drvdata,nvdimm_data,gc */ static unsigned inc_seq(unsigned seq) { static const unsigned next[] = { 0, 2, 3, 1 }; return next[seq & 3]; } static u32 best_seq(u32 a, u32 b) { a &= NSINDEX_SEQ_MASK; b &= NSINDEX_SEQ_MASK; if (a == 0 || a == b) return b; else if (b == 0) return a; else if (inc_seq(a) == b) return b; else return a; } static struct ndctl_dimm *to_dimm(struct nvdimm_data *ndd) { return container_of(ndd, struct ndctl_dimm, ndd); } static unsigned int sizeof_namespace_label(struct nvdimm_data *ndd) { return ndctl_dimm_sizeof_namespace_label(to_dimm(ndd)); } static int nvdimm_num_label_slots(struct nvdimm_data *ndd) { return ndd->config_size / (sizeof_namespace_label(ndd) + 1); } static unsigned int sizeof_namespace_index(struct nvdimm_data *ndd) { u32 nslot, space, size; struct ndctl_dimm *dimm = to_dimm(ndd); struct ndctl_ctx *ctx = ndctl_dimm_get_ctx(dimm); /* * The minimum index space is 512 bytes, with that amount of * index we can describe ~1400 labels which is less than a byte * of overhead per label. Round up to a byte of overhead per * label and determine the size of the index region. Yes, this * starts to waste space at larger config_sizes, but it's * unlikely we'll ever see anything but 128K. */ nslot = nvdimm_num_label_slots(ndd); space = ndd->config_size - nslot * sizeof_namespace_label(ndd); size = ALIGN(sizeof(struct namespace_index) + DIV_ROUND_UP(nslot, 8), NSINDEX_ALIGN) * 2; if (size <= space) return size / 2; err(ctx, "%s: label area (%ld) too small to host (%d byte) labels\n", ndctl_dimm_get_devname(dimm), ndd->config_size, sizeof_namespace_label(ndd)); return 0; } static struct namespace_index *to_namespace_index(struct nvdimm_data *ndd, int i) { char *index; if (i < 0) return NULL; index = (char *) ndd->data + sizeof_namespace_index(ndd) * i; return (struct namespace_index *) index; } static int __label_validate(struct nvdimm_data *ndd) { struct ndctl_ctx *ctx = ndctl_dimm_get_ctx(to_dimm(ndd)); /* * On media label format consists of two index blocks followed * by an array of labels. None of these structures are ever * updated in place. A sequence number tracks the current * active index and the next one to write, while labels are * written to free slots. * * +------------+ * | | * | nsindex0 | * | | * +------------+ * | | * | nsindex1 | * | | * +------------+ * | label0 | * +------------+ * | label1 | * +------------+ * | | * ....nslot... * | | * +------------+ * | labelN | * +------------+ */ struct namespace_index *nsindex[] = { to_namespace_index(ndd, 0), to_namespace_index(ndd, 1), }; const int num_index = ARRAY_SIZE(nsindex); bool valid[2] = { 0 }; int i, num_valid = 0; u32 seq; for (i = 0; i < num_index; i++) { u32 nslot; u8 sig[NSINDEX_SIG_LEN]; u64 sum_save, sum, size; unsigned int version, labelsize; memcpy(sig, nsindex[i]->sig, NSINDEX_SIG_LEN); if (memcmp(sig, NSINDEX_SIGNATURE, NSINDEX_SIG_LEN) != 0) { dbg(ctx, "nsindex%d signature invalid\n", i); continue; } /* label sizes larger than 128 arrived with v1.2 */ version = le16_to_cpu(nsindex[i]->major) * 100 + le16_to_cpu(nsindex[i]->minor); if (version >= 102) labelsize = 1 << (7 + nsindex[i]->labelsize); else labelsize = 128; if (labelsize != sizeof_namespace_label(ndd)) { dbg(ctx, "nsindex%d labelsize %d invalid\n", i, nsindex[i]->labelsize); continue; } sum_save = le64_to_cpu(nsindex[i]->checksum); nsindex[i]->checksum = cpu_to_le64(0); sum = fletcher64(nsindex[i], sizeof_namespace_index(ndd), 1); nsindex[i]->checksum = cpu_to_le64(sum_save); if (sum != sum_save) { dbg(ctx, "nsindex%d checksum invalid\n", i); continue; } seq = le32_to_cpu(nsindex[i]->seq); if ((seq & NSINDEX_SEQ_MASK) == 0) { dbg(ctx, "nsindex%d sequence: %#x invalid\n", i, seq); continue; } /* sanity check the index against expected values */ if (le64_to_cpu(nsindex[i]->myoff) != i * sizeof_namespace_index(ndd)) { dbg(ctx, "nsindex%d myoff: %#llx invalid\n", i, (unsigned long long) le64_to_cpu(nsindex[i]->myoff)); continue; } if (le64_to_cpu(nsindex[i]->otheroff) != (!i) * sizeof_namespace_index(ndd)) { dbg(ctx, "nsindex%d otheroff: %#llx invalid\n", i, (unsigned long long) le64_to_cpu(nsindex[i]->otheroff)); continue; } size = le64_to_cpu(nsindex[i]->mysize); if (size > sizeof_namespace_index(ndd) || size < sizeof(struct namespace_index)) { dbg(ctx, "nsindex%d mysize: %#zx invalid\n", i, size); continue; } nslot = le32_to_cpu(nsindex[i]->nslot); if (nslot * sizeof_namespace_label(ndd) + 2 * sizeof_namespace_index(ndd) > ndd->config_size) { dbg(ctx, "nsindex%d nslot: %u invalid, config_size: %#zx\n", i, nslot, ndd->config_size); continue; } valid[i] = true; num_valid++; } switch (num_valid) { case 0: break; case 1: for (i = 0; i < num_index; i++) if (valid[i]) return i; /* can't have num_valid > 0 but valid[] = { false, false } */ err(ctx, "unexpected index-block parse error\n"); break; default: /* pick the best index... */ seq = best_seq(le32_to_cpu(nsindex[0]->seq), le32_to_cpu(nsindex[1]->seq)); if (seq == (le32_to_cpu(nsindex[1]->seq) & NSINDEX_SEQ_MASK)) return 1; else return 0; break; } return -EINVAL; } /* * If the dimm labels have not been previously validated this routine * will make up a default size. Otherwise, it will pick the size based * on what version is specified in the index block. */ NDCTL_EXPORT unsigned int ndctl_dimm_sizeof_namespace_label(struct ndctl_dimm *dimm) { struct nvdimm_data *ndd = &dimm->ndd; struct namespace_index nsindex; ssize_t offset, size; int v1 = 0, v2 = 0; if (ndd->nslabel_size) return ndd->nslabel_size; for (offset = 0; offset < NSINDEX_ALIGN * 2; offset += NSINDEX_ALIGN) { ssize_t len = (ssize_t) sizeof(nsindex); len = ndctl_cmd_cfg_read_get_data(ndd->cmd_read, &nsindex, len, offset); if (len < 0) break; /* * Since we're doing a best effort parsing we don't * fully validate the index block. Instead just assume * v1.1 unless there's 2 index blocks that say v1.2. */ if (le16_to_cpu(nsindex.major) == 1) { if (le16_to_cpu(nsindex.minor) == 1) v1++; else if (le16_to_cpu(nsindex.minor) == 2) v2++; } } if (v2 > v1) size = 256; else size = 128; ndd->nslabel_size = size; return size; } static int label_validate(struct nvdimm_data *ndd) { /* * In order to probe for and validate namespace index blocks we * need to know the size of the labels, and we can't trust the * size of the labels until we validate the index blocks. * Resolve this dependency loop by probing for known label * sizes, but default to v1.2 256-byte namespace labels if * discovery fails. */ int label_size[] = { 128, 256 }; int i, rc; for (i = 0; (size_t) i < ARRAY_SIZE(label_size); i++) { ndd->nslabel_size = label_size[i]; rc = __label_validate(ndd); if (rc >= 0) return nvdimm_num_label_slots(ndd); } return -EINVAL; } static int nvdimm_set_config_data(struct nvdimm_data *ndd, size_t offset, void *buf, size_t len) { struct ndctl_cmd *cmd_write; int rc; cmd_write = ndctl_dimm_cmd_new_cfg_write(ndd->cmd_read); if (!cmd_write) return -ENXIO; rc = ndctl_cmd_cfg_write_set_data(cmd_write, buf, len, offset); if (rc < 0) goto out; rc = ndctl_cmd_submit(cmd_write); if (rc || ndctl_cmd_get_firmware_status(cmd_write)) rc = -ENXIO; out: ndctl_cmd_unref(cmd_write); return rc; } static int label_next_nsindex(int index) { if (index < 0) return -1; return (index + 1) % 2; } static struct namespace_label *label_base(struct nvdimm_data *ndd) { char *base = (char *) to_namespace_index(ndd, 0); base += 2 * sizeof_namespace_index(ndd); return (struct namespace_label *) base; } static void init_ndd(struct nvdimm_data *ndd, struct ndctl_cmd *cmd_read) { ndctl_cmd_unref(ndd->cmd_read); memset(ndd, 0, sizeof(*ndd)); ndd->cmd_read = cmd_read; ndctl_cmd_ref(cmd_read); ndd->data = cmd_read->iter.total_buf; ndd->config_size = cmd_read->iter.total_xfer; ndd->ns_current = -1; ndd->ns_next = -1; } static int write_label_index(struct ndctl_dimm *dimm, enum ndctl_namespace_version ver, unsigned index, unsigned seq) { struct nvdimm_data *ndd = &dimm->ndd; struct namespace_index *nsindex; unsigned long offset; u64 checksum; u32 nslot; /* * We may have initialized ndd to whatever labelsize is * currently on the dimm during label_validate(), so we reset it * to the desired version here. */ switch (ver) { case NDCTL_NS_VERSION_1_1: ndd->nslabel_size = 128; break; case NDCTL_NS_VERSION_1_2: ndd->nslabel_size = 256; break; default: return -EINVAL; } nsindex = to_namespace_index(ndd, index); nslot = nvdimm_num_label_slots(ndd); memcpy(nsindex->sig, NSINDEX_SIGNATURE, NSINDEX_SIG_LEN); memset(nsindex->flags, 0, 3); nsindex->labelsize = sizeof_namespace_label(ndd) >> 8; nsindex->seq = cpu_to_le32(seq); offset = (unsigned long) nsindex - (unsigned long) to_namespace_index(ndd, 0); nsindex->myoff = cpu_to_le64(offset); nsindex->mysize = cpu_to_le64(sizeof_namespace_index(ndd)); offset = (unsigned long) to_namespace_index(ndd, label_next_nsindex(index)) - (unsigned long) to_namespace_index(ndd, 0); nsindex->otheroff = cpu_to_le64(offset); offset = (unsigned long) label_base(ndd) - (unsigned long) to_namespace_index(ndd, 0); nsindex->labeloff = cpu_to_le64(offset); nsindex->nslot = cpu_to_le32(nslot); nsindex->major = cpu_to_le16(1); if (sizeof_namespace_label(ndd) < 256) nsindex->minor = cpu_to_le16(1); else nsindex->minor = cpu_to_le16(2); nsindex->checksum = cpu_to_le64(0); /* init label bitmap */ memset(nsindex->free, 0xff, ALIGN(nslot, BITS_PER_LONG) / 8); checksum = fletcher64(nsindex, sizeof_namespace_index(ndd), 1); nsindex->checksum = cpu_to_le64(checksum); return nvdimm_set_config_data(ndd, le64_to_cpu(nsindex->myoff), nsindex, sizeof_namespace_index(ndd)); } NDCTL_EXPORT int ndctl_dimm_init_labels(struct ndctl_dimm *dimm, enum ndctl_namespace_version v) { struct ndctl_bus *bus = ndctl_dimm_get_bus(dimm); struct ndctl_ctx *ctx = ndctl_dimm_get_ctx(dimm); struct nvdimm_data *ndd = &dimm->ndd; struct ndctl_region *region; int i; if (!ndd->cmd_read) { err(ctx, "%s: needs to be initialized by ndctl_dimm_read_labels\n", ndctl_dimm_get_devname(dimm)); return -EINVAL; } ndctl_region_foreach(bus, region) { struct ndctl_dimm *match; ndctl_dimm_foreach_in_region(region, match) if (match == dimm) { region_flag_refresh(region); break; } } for (i = 0; i < 2; i++) { int rc; rc = write_label_index(dimm, v, i, 3 - i); if (rc < 0) return rc; } return nvdimm_num_label_slots(ndd); } NDCTL_EXPORT int ndctl_dimm_validate_labels(struct ndctl_dimm *dimm) { struct ndctl_ctx *ctx = ndctl_dimm_get_ctx(dimm); struct nvdimm_data *ndd = &dimm->ndd; if (!ndd->cmd_read) { err(ctx, "%s: needs to be initialized by ndctl_dimm_read_labels\n", ndctl_dimm_get_devname(dimm)); return -EINVAL; } return label_validate(&dimm->ndd); } NDCTL_EXPORT struct ndctl_cmd *ndctl_dimm_read_labels(struct ndctl_dimm *dimm) { struct ndctl_bus *bus = ndctl_dimm_get_bus(dimm); struct ndctl_cmd *cmd_size, *cmd_read; int rc; rc = ndctl_bus_wait_probe(bus); if (rc < 0) return NULL; cmd_size = ndctl_dimm_cmd_new_cfg_size(dimm); if (!cmd_size) return NULL; rc = ndctl_cmd_submit(cmd_size); if (rc || ndctl_cmd_get_firmware_status(cmd_size)) goto out_size; cmd_read = ndctl_dimm_cmd_new_cfg_read(cmd_size); if (!cmd_read) goto out_size; rc = ndctl_cmd_submit(cmd_read); if (rc || ndctl_cmd_get_firmware_status(cmd_read)) goto out_read; ndctl_cmd_unref(cmd_size); init_ndd(&dimm->ndd, cmd_read); return cmd_read; out_read: ndctl_cmd_unref(cmd_read); out_size: ndctl_cmd_unref(cmd_size); return NULL; } NDCTL_EXPORT int ndctl_dimm_zero_labels(struct ndctl_dimm *dimm) { struct ndctl_ctx *ctx = ndctl_dimm_get_ctx(dimm); struct ndctl_cmd *cmd_read, *cmd_write; int rc; cmd_read = ndctl_dimm_read_labels(dimm); if (!cmd_read) return -ENXIO; if (ndctl_dimm_is_active(dimm)) { dbg(ctx, "%s: regions active, abort label write\n", ndctl_dimm_get_devname(dimm)); rc = -EBUSY; goto out_read; } cmd_write = ndctl_dimm_cmd_new_cfg_write(cmd_read); if (!cmd_write) { rc = -ENOTTY; goto out_read; } if (ndctl_cmd_cfg_write_zero_data(cmd_write) < 0) { rc = -ENXIO; goto out_write; } rc = ndctl_cmd_submit(cmd_write); if (rc || ndctl_cmd_get_firmware_status(cmd_write)) goto out_write; /* * If the dimm is already disabled the kernel is not holding a cached * copy of the label space. */ if (!ndctl_dimm_is_enabled(dimm)) goto out_write; rc = ndctl_dimm_disable(dimm); if (rc) goto out_write; rc = ndctl_dimm_enable(dimm); out_write: ndctl_cmd_unref(cmd_write); out_read: ndctl_cmd_unref(cmd_read); return rc; } NDCTL_EXPORT unsigned long ndctl_dimm_get_available_labels( struct ndctl_dimm *dimm) { struct ndctl_ctx *ctx = ndctl_dimm_get_ctx(dimm); char *path = dimm->dimm_buf; int len = dimm->buf_len; char buf[20]; if (snprintf(path, len, "%s/available_slots", dimm->dimm_path) >= len) { err(ctx, "%s: buffer too small!\n", ndctl_dimm_get_devname(dimm)); return ULONG_MAX; } if (sysfs_read_attr(ctx, path, buf) < 0) return ULONG_MAX; return strtoul(buf, NULL, 0); } ndctl-61.2/ndctl/lib/firmware.c000066400000000000000000000056551331777607200164300ustar00rootroot00000000000000/* SPDX-License-Identifier: GPL-2.0 */ /* Copyright(c) 2018 Intel Corporation. All rights reserved. */ #include #include #include #include #include "private.h" /* * Define the wrappers around the ndctl_dimm_ops for firmware update: */ NDCTL_EXPORT struct ndctl_cmd * ndctl_dimm_cmd_new_fw_get_info(struct ndctl_dimm *dimm) { struct ndctl_dimm_ops *ops = dimm->ops; if (ops && ops->new_fw_get_info) return ops->new_fw_get_info(dimm); else return NULL; } NDCTL_EXPORT struct ndctl_cmd * ndctl_dimm_cmd_new_fw_start_update(struct ndctl_dimm *dimm) { struct ndctl_dimm_ops *ops = dimm->ops; if (ops && ops->new_fw_start_update) return ops->new_fw_start_update(dimm); else return NULL; } NDCTL_EXPORT struct ndctl_cmd * ndctl_dimm_cmd_new_fw_send(struct ndctl_cmd *start, unsigned int offset, unsigned int len, void *data) { struct ndctl_dimm_ops *ops = start->dimm->ops; if (ops && ops->new_fw_send) return ops->new_fw_send(start, offset, len, data); else return NULL; } NDCTL_EXPORT struct ndctl_cmd * ndctl_dimm_cmd_new_fw_finish(struct ndctl_cmd *start) { struct ndctl_dimm_ops *ops = start->dimm->ops; if (ops && ops->new_fw_finish) return ops->new_fw_finish(start); else return NULL; } NDCTL_EXPORT struct ndctl_cmd * ndctl_dimm_cmd_new_fw_abort(struct ndctl_cmd *start) { struct ndctl_dimm_ops *ops = start->dimm->ops; if (ops && ops->new_fw_finish) return ops->new_fw_abort(start); else return NULL; } NDCTL_EXPORT struct ndctl_cmd * ndctl_dimm_cmd_new_fw_finish_query(struct ndctl_cmd *start) { struct ndctl_dimm_ops *ops = start->dimm->ops; if (ops && ops->new_fw_finish_query) return ops->new_fw_finish_query(start); else return NULL; } #define firmware_cmd_op(op, rettype, defretvalue) \ NDCTL_EXPORT rettype ndctl_cmd_##op(struct ndctl_cmd *cmd) \ { \ if (cmd->dimm) { \ struct ndctl_dimm_ops *ops = cmd->dimm->ops; \ if (ops && ops->op) \ return ops->op(cmd); \ } \ return defretvalue; \ } firmware_cmd_op(fw_info_get_storage_size, unsigned int, 0) firmware_cmd_op(fw_info_get_max_send_len, unsigned int, 0) firmware_cmd_op(fw_info_get_query_interval, unsigned int, 0) firmware_cmd_op(fw_info_get_max_query_time, unsigned int, 0) firmware_cmd_op(fw_info_get_run_version, unsigned long long, 0) firmware_cmd_op(fw_info_get_updated_version, unsigned long long, 0) firmware_cmd_op(fw_start_get_context, unsigned int, 0) firmware_cmd_op(fw_fquery_get_fw_rev, unsigned long long, 0) NDCTL_EXPORT enum ND_FW_STATUS ndctl_cmd_fw_xlat_firmware_status(struct ndctl_cmd *cmd) { struct ndctl_dimm_ops *ops = cmd->dimm->ops; if (ops && ops->fw_xlat_firmware_status) return ops->fw_xlat_firmware_status(cmd); else return FW_EUNKNOWN; } NDCTL_EXPORT int ndctl_dimm_fw_update_supported(struct ndctl_dimm *dimm) { struct ndctl_dimm_ops *ops = dimm->ops; if (ops && ops->fw_update_supported) return ops->fw_update_supported(dimm); else return -ENOTTY; } ndctl-61.2/ndctl/lib/hpe1.c000066400000000000000000000212021331777607200154330ustar00rootroot00000000000000/* * Copyright (C) 2016 Hewlett Packard Enterprise Development LP * Copyright (c) 2016, Intel Corporation. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU Lesser General Public License, * version 2.1, as published by the Free Software Foundation. * * This program is distributed in the hope 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. */ #include #include #include #include #include "private.h" #include "hpe1.h" #define CMD_HPE1(_c) ((_c)->hpe1) #define CMD_HPE1_SMART(_c) (CMD_HPE1(_c)->u.smart.data) #define CMD_HPE1_SMART_THRESH(_c) (CMD_HPE1(_c)->u.thresh.data) static struct ndctl_cmd *hpe1_dimm_cmd_new_smart(struct ndctl_dimm *dimm) { struct ndctl_bus *bus = ndctl_dimm_get_bus(dimm); struct ndctl_ctx *ctx = ndctl_bus_get_ctx(bus); struct ndctl_cmd *cmd; size_t size; struct ndn_pkg_hpe1 *hpe1; if (!ndctl_dimm_is_cmd_supported(dimm, ND_CMD_CALL)) { dbg(ctx, "unsupported cmd\n"); return NULL; } if (test_dimm_dsm(dimm, NDN_HPE1_CMD_SMART) == DIMM_DSM_UNSUPPORTED) { dbg(ctx, "unsupported function\n"); return NULL; } size = sizeof(*cmd) + sizeof(struct ndn_pkg_hpe1); cmd = calloc(1, size); if (!cmd) return NULL; cmd->dimm = dimm; ndctl_cmd_ref(cmd); cmd->type = ND_CMD_CALL; cmd->size = size; cmd->status = 1; hpe1 = CMD_HPE1(cmd); hpe1->gen.nd_family = NVDIMM_FAMILY_HPE1; hpe1->gen.nd_command = NDN_HPE1_CMD_SMART; hpe1->gen.nd_fw_size = 0; hpe1->gen.nd_size_in = offsetof(struct ndn_hpe1_smart, status); hpe1->gen.nd_size_out = sizeof(hpe1->u.smart); hpe1->u.smart.status = 3; hpe1->u.smart.in_valid_flags = 0; hpe1->u.smart.in_valid_flags |= NDN_HPE1_SMART_HEALTH_VALID; hpe1->u.smart.in_valid_flags |= NDN_HPE1_SMART_TEMP_VALID; hpe1->u.smart.in_valid_flags |= NDN_HPE1_SMART_SPARES_VALID; hpe1->u.smart.in_valid_flags |= NDN_HPE1_SMART_ALARM_VALID; hpe1->u.smart.in_valid_flags |= NDN_HPE1_SMART_USED_VALID; hpe1->u.smart.in_valid_flags |= NDN_HPE1_SMART_SHUTDOWN_VALID; hpe1->u.smart.in_valid_flags |= NDN_HPE1_SMART_VENDOR_VALID; cmd->firmware_status = &hpe1->u.smart.status; return cmd; } static int hpe1_smart_valid(struct ndctl_cmd *cmd) { if (cmd->type != ND_CMD_CALL || cmd->size != sizeof(*cmd) + sizeof(struct ndn_pkg_hpe1) || CMD_HPE1(cmd)->gen.nd_family != NVDIMM_FAMILY_HPE1 || CMD_HPE1(cmd)->gen.nd_command != NDN_HPE1_CMD_SMART || cmd->status != 0) return cmd->status < 0 ? cmd->status : -EINVAL; return 0; } static unsigned int hpe1_cmd_smart_get_flags(struct ndctl_cmd *cmd) { unsigned int hpe1flags; unsigned int flags; if (hpe1_smart_valid(cmd) < 0) return UINT_MAX; hpe1flags = CMD_HPE1_SMART(cmd)->out_valid_flags; flags = 0; if (hpe1flags & NDN_HPE1_SMART_HEALTH_VALID) flags |= ND_SMART_HEALTH_VALID; if (hpe1flags & NDN_HPE1_SMART_TEMP_VALID) flags |= ND_SMART_TEMP_VALID ; if (hpe1flags & NDN_HPE1_SMART_SPARES_VALID) flags |= ND_SMART_SPARES_VALID; if (hpe1flags & NDN_HPE1_SMART_ALARM_VALID) flags |= ND_SMART_ALARM_VALID; if (hpe1flags & NDN_HPE1_SMART_USED_VALID) flags |= ND_SMART_USED_VALID; if (hpe1flags & NDN_HPE1_SMART_SHUTDOWN_VALID) flags |= ND_SMART_SHUTDOWN_VALID; if (hpe1flags & NDN_HPE1_SMART_VENDOR_VALID) flags |= ND_SMART_VENDOR_VALID; return flags; } static unsigned int hpe1_cmd_smart_get_health(struct ndctl_cmd *cmd) { unsigned char hpe1health; unsigned int health; if (hpe1_smart_valid(cmd) < 0) return UINT_MAX; hpe1health = CMD_HPE1_SMART(cmd)->stat_summary; health = 0; if (hpe1health & NDN_HPE1_SMART_NONCRIT_HEALTH) health |= ND_SMART_NON_CRITICAL_HEALTH;; if (hpe1health & NDN_HPE1_SMART_CRITICAL_HEALTH) health |= ND_SMART_CRITICAL_HEALTH; if (hpe1health & NDN_HPE1_SMART_FATAL_HEALTH) health |= ND_SMART_FATAL_HEALTH; return health; } static unsigned int hpe1_cmd_smart_get_media_temperature(struct ndctl_cmd *cmd) { if (hpe1_smart_valid(cmd) < 0) return UINT_MAX; return CMD_HPE1_SMART(cmd)->curr_temp; } static unsigned int hpe1_cmd_smart_get_spares(struct ndctl_cmd *cmd) { if (hpe1_smart_valid(cmd) < 0) return UINT_MAX; return CMD_HPE1_SMART(cmd)->spare_blocks; } static unsigned int hpe1_cmd_smart_get_alarm_flags(struct ndctl_cmd *cmd) { unsigned int hpe1flags; unsigned int flags; if (hpe1_smart_valid(cmd) < 0) return UINT_MAX; hpe1flags = CMD_HPE1_SMART(cmd)->alarm_trips; flags = 0; if (hpe1flags & NDN_HPE1_SMART_TEMP_TRIP) flags |= ND_SMART_TEMP_TRIP; if (hpe1flags & NDN_HPE1_SMART_SPARE_TRIP) flags |= ND_SMART_SPARE_TRIP; return flags; } static unsigned int hpe1_cmd_smart_get_life_used(struct ndctl_cmd *cmd) { if (hpe1_smart_valid(cmd) < 0) return UINT_MAX; return CMD_HPE1_SMART(cmd)->device_life; } static unsigned int hpe1_cmd_smart_get_shutdown_state(struct ndctl_cmd *cmd) { unsigned int shutdown; if (hpe1_smart_valid(cmd) < 0) return UINT_MAX; shutdown = CMD_HPE1_SMART(cmd)->last_shutdown_stat; if (shutdown == NDN_HPE1_SMART_LASTSAVEGOOD) return 0; else return 1; } static unsigned int hpe1_cmd_smart_get_vendor_size(struct ndctl_cmd *cmd) { if (hpe1_smart_valid(cmd) < 0) return UINT_MAX; return CMD_HPE1_SMART(cmd)->vndr_spec_data_size; } static unsigned char *hpe1_cmd_smart_get_vendor_data(struct ndctl_cmd *cmd) { if (hpe1_smart_valid(cmd) < 0) return NULL; return CMD_HPE1_SMART(cmd)->vnd_spec_data; } static struct ndctl_cmd *hpe1_dimm_cmd_new_smart_threshold(struct ndctl_dimm *dimm) { struct ndctl_bus *bus = ndctl_dimm_get_bus(dimm); struct ndctl_ctx *ctx = ndctl_bus_get_ctx(bus); struct ndctl_cmd *cmd; size_t size; struct ndn_pkg_hpe1 *hpe1; if (!ndctl_dimm_is_cmd_supported(dimm, ND_CMD_CALL)) { dbg(ctx, "unsupported cmd\n"); return NULL; } if (test_dimm_dsm(dimm, NDN_HPE1_CMD_SMART_THRESHOLD) == DIMM_DSM_UNSUPPORTED) { dbg(ctx, "unsupported function\n"); return NULL; } size = sizeof(*cmd) + sizeof(struct ndn_pkg_hpe1); cmd = calloc(1, size); if (!cmd) return NULL; cmd->dimm = dimm; ndctl_cmd_ref(cmd); cmd->type = ND_CMD_CALL; cmd->size = size; cmd->status = 1; hpe1 = CMD_HPE1(cmd); hpe1->gen.nd_family = NVDIMM_FAMILY_HPE1; hpe1->gen.nd_command = NDN_HPE1_CMD_SMART_THRESHOLD; hpe1->gen.nd_fw_size = 0; hpe1->gen.nd_size_in = offsetof(struct ndn_hpe1_smart_threshold, status); hpe1->gen.nd_size_out = sizeof(hpe1->u.smart); hpe1->u.thresh.status = 3; cmd->firmware_status = &hpe1->u.thresh.status; return cmd; } static int hpe1_smart_threshold_valid(struct ndctl_cmd *cmd) { if (cmd->type != ND_CMD_CALL || cmd->size != sizeof(*cmd) + sizeof(struct ndn_pkg_hpe1) || CMD_HPE1(cmd)->gen.nd_family != NVDIMM_FAMILY_HPE1 || CMD_HPE1(cmd)->gen.nd_command != NDN_HPE1_CMD_SMART_THRESHOLD || cmd->status != 0) return cmd->status < 0 ? cmd->status : -EINVAL; return 0; } static unsigned int hpe1_cmd_smart_threshold_get_alarm_control(struct ndctl_cmd *cmd) { unsigned int hpe1flags; unsigned int flags; if (hpe1_smart_threshold_valid(cmd) < 0) return UINT_MAX; hpe1flags = CMD_HPE1_SMART_THRESH(cmd)->threshold_alarm_ctl; flags = 0; if (hpe1flags & NDN_HPE1_SMART_TEMP_TRIP) flags |= ND_SMART_TEMP_TRIP; if (hpe1flags & NDN_HPE1_SMART_SPARE_TRIP) flags |= ND_SMART_SPARE_TRIP; return flags; } static unsigned int hpe1_cmd_smart_threshold_get_media_temperature( struct ndctl_cmd *cmd) { if (hpe1_smart_threshold_valid(cmd) < 0) return UINT_MAX; return CMD_HPE1_SMART_THRESH(cmd)->temp_threshold; } static unsigned int hpe1_cmd_smart_threshold_get_spares(struct ndctl_cmd *cmd) { if (hpe1_smart_threshold_valid(cmd) < 0) return UINT_MAX; return CMD_HPE1_SMART_THRESH(cmd)->spare_block_threshold; } struct ndctl_dimm_ops * const hpe1_dimm_ops = &(struct ndctl_dimm_ops) { .new_smart = hpe1_dimm_cmd_new_smart, .smart_get_flags = hpe1_cmd_smart_get_flags, .smart_get_health = hpe1_cmd_smart_get_health, .smart_get_media_temperature = hpe1_cmd_smart_get_media_temperature, .smart_get_spares = hpe1_cmd_smart_get_spares, .smart_get_alarm_flags = hpe1_cmd_smart_get_alarm_flags, .smart_get_life_used = hpe1_cmd_smart_get_life_used, .smart_get_shutdown_state = hpe1_cmd_smart_get_shutdown_state, .smart_get_vendor_size = hpe1_cmd_smart_get_vendor_size, .smart_get_vendor_data = hpe1_cmd_smart_get_vendor_data, .new_smart_threshold = hpe1_dimm_cmd_new_smart_threshold, .smart_threshold_get_alarm_control = hpe1_cmd_smart_threshold_get_alarm_control, .smart_threshold_get_media_temperature = hpe1_cmd_smart_threshold_get_media_temperature, .smart_threshold_get_spares = hpe1_cmd_smart_threshold_get_spares, }; ndctl-61.2/ndctl/lib/hpe1.h000066400000000000000000000222301331777607200154420ustar00rootroot00000000000000/* * Copyright (C) 2016 Hewlett Packard Enterprise Development LP * Copyright (c) 2014-2015, Intel Corporation. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU Lesser General Public License, * version 2.1, as published by the Free Software Foundation. * * This program is distributed in the hope 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. */ #ifndef __NDCTL_HPE1_H__ #define __NDCTL_HPE1_H__ enum { NDN_HPE1_CMD_QUERY = 0, /* non-root commands */ NDN_HPE1_CMD_SMART = 1, NDN_HPE1_CMD_SMART_THRESHOLD = 2, NDN_HPE1_CMD_GET_CONFIG_SIZE = 4, NDN_HPE1_CMD_GET_CONFIG_DATA = 5, NDN_HPE1_CMD_SET_CONFIG_DATA = 6, NDN_HPE1_CMD_GET_IDENT = 10, NDN_HPE1_CMD_GET_ES_IDENT = 11, NDN_HPE1_CMD_GET_LAST_BACKUP = 12, NDN_HPE1_CMD_SET_LIFE_THRESHOLD = 13, NDN_HPE1_CMD_ERRINJ_QUERY = 18, NDN_HPE1_CMD_ERRINJ_INJECT = 19, NDN_HPE1_CMD_ERRINJ_STATUS = 20, }; /* NDN_HPE1_CMD_SMART */ /* ndn_hpe1_smart.in_valid_flags / ndn_hpe1_smart_data.out_valid_flags */ #define NDN_HPE1_SMART_HEALTH_VALID (1 << 0) #define NDN_HPE1_SMART_TEMP_VALID (1 << 1) #define NDN_HPE1_SMART_SPARES_VALID (1 << 2) #define NDN_HPE1_SMART_ALARM_VALID (1 << 3) #define NDN_HPE1_SMART_USED_VALID (1 << 4) #define NDN_HPE1_SMART_SHUTDOWN_VALID (1 << 5) #define NDN_HPE1_SMART_STATS_VALID (1 << 6) #define NDN_HPE1_SMART_DETAIL_VALID (1 << 7) #define NDN_HPE1_SMART_ENERGY_VALID (1 << 8) #define NDN_HPE1_SMART_VENDOR_VALID (1 << 9) #define NDN_HPE1_SMART_NOTIFIED (1 << 31) /* ndn_hpe1_smart_data.stat_summary */ #define NDN_HPE1_SMART_NONCRIT_HEALTH (1 << 0) #define NDN_HPE1_SMART_CRITICAL_HEALTH (1 << 1) #define NDN_HPE1_SMART_FATAL_HEALTH (1 << 2) /* ndn_hpe1_smart_data.alarm_trips */ #define NDN_HPE1_SMART_TEMP_TRIP (1 << 0) #define NDN_HPE1_SMART_SPARE_TRIP (1 << 1) #define NDN_HPE1_SMART_LIFEWARN_TRIP (1 << 2) #define NDN_HPE1_SMART_LIFEERR_TRIP (1 << 3) #define NDN_HPE1_SMART_ESLIFEWARN_TRIP (1 << 4) #define NDN_HPE1_SMART_ESLIFEERR_TRIP (1 << 5) #define NDN_HPE1_SMART_ESTEMPWARN_TRIP (1 << 6) #define NDN_HPE1_SMART_ESTEMPERR_TRIP (1 << 7) /* ndn_hpe1_smart_data.last_shutdown_stat */ #define NDN_HPE1_SMART_LASTSAVEGOOD (1 << 1) /* ndn_hpe1_smart_data.mod_hlth_stat */ #define NDN_HPE1_SMART_ES_FAILURE (1 << 0) #define NDN_HPE1_SMART_CTLR_FAILURE (1 << 1) #define NDN_HPE1_SMART_UE_TRIP (1 << 2) #define NDN_HPE1_SMART_CE_TRIP (1 << 3) #define NDN_HPE1_SMART_SAVE_FAILED (1 << 4) #define NDN_HPE1_SMART_RESTORE_FAILED (1 << 5) #define NDN_HPE1_SMART_ARM_FAILED (1 << 6) #define NDN_HPE1_SMART_ERASE_FAILED (1 << 7) #define NDN_HPE1_SMART_CONFIG_ERROR (1 << 8) #define NDN_HPE1_SMART_FW_ERROR (1 << 9) #define NDN_HPE1_SMART_VENDOR_ERROR (1 << 10) struct ndn_hpe1_smart_data { __u32 out_valid_flags; __u8 stat_summary; __u16 curr_temp; __u8 spare_blocks; __u16 alarm_trips; __u8 device_life; __u8 last_shutdown_stat; __u16 last_save_op_dur; __u16 last_restore_op_dur; __u16 last_erase_op_dur; __u16 res1; __u32 save_ops; __u32 restore_ops; __u32 erase_ops; __u32 life_save_ops; __u32 life_restore_ops; __u32 life_erase_ops; __u32 life_mod_pwr_cycles; __u32 mod_hlth_stat; __u32 energy_src_check; __u8 energy_src_life_percent; __u16 energy_src_curr_temp; __u8 res2; __u16 energy_src_total_runtime; __u16 vndr_spec_data_size; __u8 vnd_spec_data[60]; } __attribute__((packed)); struct ndn_hpe1_smart { __u32 in_valid_flags; __u32 status; union { __u8 buf[124]; struct ndn_hpe1_smart_data data[0]; }; } __attribute__((packed)); /* NDN_HPE1_CMD_SMART_THRESHOLD */ struct ndn_hpe1_smart_threshold_data { __u16 threshold_alarm_ctl; __u16 temp_threshold; __u8 spare_block_threshold; __u8 res1[3]; __u8 dev_lifewarn_threshold; __u8 dev_lifeerr_threshold; __u8 res2[6]; __u8 es_lifewarn_threshold; __u8 es_lifeerr_threshold; __u8 es_tempwarn_threshold; __u8 es_temperr_threshold; __u8 res3[4]; __u64 res4; } __attribute__((packed)); struct ndn_hpe1_smart_threshold { __u32 status; union { __u8 buf[32]; struct ndn_hpe1_smart_threshold_data data[0]; }; } __attribute__((packed)); /* NDN_HPE1_CMD_GET_CONFIG_SIZE */ struct ndn_hpe1_get_config_size { __u32 status; __u32 config_size; __u32 max_xfer; } __attribute__((packed)); /* NDN_HPE1_CMD_GET_CONFIG_DATA */ struct ndn_hpe1_get_config_data_hdr { __u32 in_offset; __u32 in_length; __u32 status; __u8 out_buf[0]; } __attribute__((packed)); /* NDN_HPE1_CMD_SET_CONFIG_DATA */ struct ndn_hpe1_set_config_hdr { __u32 in_offset; __u32 in_length; __u8 in_buf[0]; } __attribute__((packed)); /* ndn_hpe1_get_id.sup_backup_trigger */ #define NDN_HPE1_BKUP_SUPPORT_CKE (1 << 0) #define NDN_HPE1_BKUP_SUPPORT_EXTERNAL (1 << 1) #define NDN_HPE1_BKUP_SUPPORT_12V (1 << 2) #define NDN_HPE1_BKUP_SUPPORT_I2C (1 << 3) #define NDN_HPE1_BKUP_SUPPORT_SAVEN (1 << 4) /* NDN_HPE1_CMD_GET_IDENT */ struct ndn_hpe1_get_id { __u32 status; __u8 spec_rev; __u8 num_stnd_pages; __u32 hw_rev; __u8 sup_backup_trigger; __u16 max_op_retries; __u8 __res1[3]; __u32 backup_op_timeout; __u32 restore_op_timeout; __u32 erase_op_timeout; __u32 arm_op_timeout; __u32 fw_op_timeout; __u32 region_block_size; __u16 min_op_temp; __u16 max_op_temp; __u8 curr_fw_slot; __u8 res2[1]; __u16 num_fw_slots; __u8 fw_slot_revision[0]; } __attribute__((packed)); /* ndn_hpe1_get_energy_src_id.attr */ #define NDN_HPE1_ES_ATTR_BUILTIN (1 << 0) #define NDN_HPE1_ES_ATTR_TETHERED (1 << 1) #define NDN_HPE1_ES_ATTR_SHARED (1 << 2) /* ndn_hpe1_get_energy_src_id.tech */ #define NDN_HPE1_ES_TECH_UNDEFINED (1 << 0) #define NDN_HPE1_ES_TECH_SUPERCAP (1 << 1) #define NDN_HPE1_ES_TECH_BATTERY (1 << 2) #define NDN_HPE1_ES_TECH_HYBRIDCAP (1 << 3) /* NDN_HPE1_CMD_GET_ES_IDENT */ struct ndn_hpe1_get_energy_src_id { __u32 status; __u8 energy_src_policy; __u8 attr; __u8 tech; __u8 reserved; __u16 hw_rev; __u16 fw_rev; __u32 charge_timeout; __u16 min_op_temp; __u16 max_op_temp; } __attribute__((packed)); /* ndn_hpe1_last_backup_info.last_backup_initiation */ #define NDN_HPE1_LASTBKUP_SAVEN (1 << 0) #define NDN_HPE1_LASTBKUP_EXTERNAL (1 << 1) #define NDN_HPE1_LASTBKUP_CKE (1 << 2) #define NDN_HPE1_LASTBKUP_FW (1 << 3) #define NDN_HPE1_LASTBKUP_RESETN (1 << 4) /* ndn_hpe1_last_backup_info.ctlr_backup_stat */ #define NDN_HPE1_LASTBKUP_GTG (1 << 0) #define NDN_HPE1_LASTBKUP_SDRAM_FAULT (1 << 1) #define NDN_HPE1_LASTBKUP_GEN_FAULT (1 << 2) /* NDN_HPE1_CMD_GET_LAST_BACKUP */ struct ndn_hpe1_get_last_backup { __u32 status; __u32 last_backup_info; } __attribute__((packed)); struct ndn_hpe1_last_backup_info { __u8 backup_image; __u8 backup_cmplt_stat; __u8 last_backup_initiation; __u8 ctlr_backup_stat; } __attribute__((packed)); /* NDN_HPE1_CMD_SET_LIFE_THRESHOLD */ struct ndn_hpe1_set_lifetime_threshold { __u8 in_nvm_lifetime_warn_threshold; __u32 status; } __attribute__((packed)); /* ndn_hpe1_inj_err.in_err_typ * ndn_hpe1_get_inj_err_status.err_inj_type * log2(ndn_hpe1_query_err_inj_cap.err_inj_cap) */ enum { NDN_HPE1_EINJ_DEV_NONCRIT = 1, NDN_HPE1_EINJ_DEV_CRIT = 2, NDN_HPE1_EINJ_DEV_FATAL = 3, NDN_HPE1_EINJ_UE_BACKUP = 4, NDN_HPE1_EINJ_UE_RESTORE = 5, NDN_HPE1_EINJ_UE_ERASE = 6, NDN_HPE1_EINJ_UE_ARM = 7, NDN_HPE1_EINJ_BADBLOCK = 8, NDN_HPE1_EINJ_ES_FAULT = 9, NDN_HPE1_EINJ_ES_LOWCHARGE = 10, NDN_HPE1_EINJ_ES_TEMPWARN = 11, NDN_HPE1_EINJ_ES_TEMPERR = 12, NDN_HPE1_EINJ_ES_LIFEWARN = 13, NDN_HPE1_EINJ_ES_LIFEERR = 14, NDN_HPE1_EINJ_DEV_LIFEWARN = 15, NDN_HPE1_EINJ_DEV_LIFEERR = 16, NDN_HPE1_EINJ_FWUPDATE_ERR = 17, NDN_HPE1_EINJ_CTRL_ERR = 18, }; /* ndn_hpe1_inj_err.in_options / ndn_hpe1_get_inj_err_status.err_inj_opt */ enum { NDN_HPE1_EINJ_OPT_SINGLE = 0, NDN_HPE1_EINJ_OPT_PERSISTENT = 1, NDN_HPE1_EINJ_OPT_CLEAR = 2, }; /* ndn_hpe1_get_inj_err_status.err_inj_stat_info */ enum { NDN_HPE1_EINJ_STAT_NONE = 0, NDN_HPE1_EINJ_STAT_INJECTED = 1, NDN_HPE1_EINJ_STAT_PENDING = 2, }; /* NDN_HPE1_CMD_ERRINJ_QUERY */ struct ndn_hpe1_query_err_inj_cap { __u32 status; __u8 err_inj_cap[32]; } __attribute__((packed)); /* NDN_HPE1_CMD_ERRINJ_INJECT */ struct ndn_hpe1_inj_err { __u8 in_err_typ; __u8 in_options; __u32 status; } __attribute__((packed)); /* NDN_HPE1_CMD_ERRINJ_STATUS */ struct ndn_hpe1_get_inj_err_status { __u32 status; __u8 err_inj_stat_info; __u8 err_inj_type; __u8 err_inj_opt; } __attribute__((packed)); union ndn_hpe1_cmd { __u64 query; struct ndn_hpe1_smart smart; struct ndn_hpe1_smart_threshold thresh; struct ndn_hpe1_get_config_size get_size; struct ndn_hpe1_get_config_data_hdr get_data; struct ndn_hpe1_get_id get_id; struct ndn_hpe1_get_energy_src_id get_energy_src_id; struct ndn_hpe1_get_last_backup get_last_backup; struct ndn_hpe1_last_backup_info last_backup_info; struct ndn_hpe1_set_lifetime_threshold set_life_thresh; struct ndn_hpe1_query_err_inj_cap err_cap; struct ndn_hpe1_inj_err inj_err; struct ndn_hpe1_get_inj_err_status inj_err_stat; unsigned char buf[128]; }; struct ndn_pkg_hpe1 { struct nd_cmd_pkg gen; union ndn_hpe1_cmd u; } __attribute__((packed)); #define NDN_IOCTL_HPE1_PASSTHRU _IOWR(ND_IOCTL, ND_CMD_CALL, \ struct ndn_pkg_hpe1) #endif /* __NDCTL_HPE1_H__ */ ndctl-61.2/ndctl/lib/inject.c000066400000000000000000000314651331777607200160660ustar00rootroot00000000000000/* * Copyright (c) 2014-2017, Intel Corporation. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU Lesser General Public License, * version 2.1, as published by the Free Software Foundation. * * This program is distributed in the hope 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. */ #include #include #include #include #include #include #include #include #include "private.h" NDCTL_EXPORT int ndctl_bus_has_error_injection(struct ndctl_bus *bus) { /* Currently, only nfit buses have error injection */ if (!bus || !ndctl_bus_has_nfit(bus)) return 0; if (ndctl_bus_is_nfit_cmd_supported(bus, NFIT_CMD_ARS_INJECT_SET) && ndctl_bus_is_nfit_cmd_supported(bus, NFIT_CMD_ARS_INJECT_GET) && ndctl_bus_is_nfit_cmd_supported(bus, NFIT_CMD_ARS_INJECT_CLEAR)) return 1; return 0; } static void ndctl_namespace_get_injection_bounds( struct ndctl_namespace *ndns, unsigned long long *ns_offset, unsigned long long *ns_size) { struct ndctl_pfn *pfn = ndctl_namespace_get_pfn(ndns); struct ndctl_dax *dax = ndctl_namespace_get_dax(ndns); if (!ns_offset || !ns_size) return; if (pfn) { *ns_offset = ndctl_pfn_get_resource(pfn); *ns_size = ndctl_pfn_get_size(pfn); return; } else if (dax) { *ns_offset = ndctl_dax_get_resource(dax); *ns_size = ndctl_dax_get_size(dax); return; } /* raw or btt */ *ns_offset = ndctl_namespace_get_resource(ndns); *ns_size = ndctl_namespace_get_size(ndns); } static int block_to_spa_offset(struct ndctl_namespace *ndns, unsigned long long block, unsigned long long count, u64 *offset, u64 *length) { struct ndctl_ctx *ctx = ndctl_namespace_get_ctx(ndns); unsigned long long ns_offset, ns_size; ndctl_namespace_get_injection_bounds(ndns, &ns_offset, &ns_size); *offset = ns_offset + block * 512; *length = count * 512; /* check bounds */ if (*offset + *length > ns_offset + ns_size) { dbg(ctx, "Error: block %#llx, count %#llx are out of bounds\n", block, count); return -EINVAL; } return 0; } static int translate_status(u32 status) { switch (status) { case ND_ARS_ERR_INJ_STATUS_NOT_SUPP: return -EOPNOTSUPP; case ND_ARS_ERR_INJ_STATUS_INVALID_PARAM: return -EINVAL; } return 0; } static int ndctl_namespace_get_clear_unit(struct ndctl_namespace *ndns) { struct ndctl_bus *bus = ndctl_namespace_get_bus(ndns); struct ndctl_ctx *ctx = ndctl_bus_get_ctx(bus); unsigned long long ns_offset, ns_size; unsigned int clear_unit; struct ndctl_cmd *cmd; int rc; ndctl_namespace_get_injection_bounds(ndns, &ns_offset, &ns_size); cmd = ndctl_bus_cmd_new_ars_cap(bus, ns_offset, ns_size); rc = ndctl_cmd_submit(cmd); if (rc) { dbg(ctx, "Error submitting ars_cap: %d\n", rc); return rc; } clear_unit = ndctl_cmd_ars_cap_get_clear_unit(cmd); if (clear_unit == 0) { dbg(ctx, "Got an invalid clear_err_unit from ars_cap\n"); return -EINVAL; } ndctl_cmd_unref(cmd); return clear_unit; } static int ndctl_namespace_inject_one_error(struct ndctl_namespace *ndns, unsigned long long block, unsigned int flags) { struct ndctl_bus *bus = ndctl_namespace_get_bus(ndns); struct ndctl_ctx *ctx = ndctl_bus_get_ctx(bus); struct nd_cmd_ars_err_inj *err_inj; struct nd_cmd_pkg *pkg; struct ndctl_cmd *cmd; u64 offset, length; int rc, clear_unit; rc = block_to_spa_offset(ndns, block, 1, &offset, &length); if (rc) return rc; clear_unit = ndctl_namespace_get_clear_unit(ndns); if (clear_unit < 0) return clear_unit; if (!(flags & (1 << NDCTL_NS_INJECT_SATURATE))) { /* clamp injection length per block to the clear_unit */ if (length > (unsigned int)clear_unit) length = clear_unit; } cmd = ndctl_bus_cmd_new_err_inj(bus); if (!cmd) return -ENOMEM; pkg = (struct nd_cmd_pkg *)&cmd->cmd_buf[0]; err_inj = (struct nd_cmd_ars_err_inj *)&pkg->nd_payload[0]; err_inj->err_inj_spa_range_base = offset; err_inj->err_inj_spa_range_length = length; if (flags & (1 << NDCTL_NS_INJECT_NOTIFY)) err_inj->err_inj_options |= (1 << ND_ARS_ERR_INJ_OPT_NOTIFY); rc = ndctl_cmd_submit(cmd); if (rc) { dbg(ctx, "Error submitting command: %d\n", rc); goto out; } rc = translate_status(err_inj->status); out: ndctl_cmd_unref(cmd); return rc; } NDCTL_EXPORT int ndctl_namespace_inject_error2(struct ndctl_namespace *ndns, unsigned long long block, unsigned long long count, unsigned int flags) { struct ndctl_bus *bus = ndctl_namespace_get_bus(ndns); struct ndctl_ctx *ctx = ndctl_bus_get_ctx(bus); unsigned long long i; int rc = -EINVAL; if (!ndctl_bus_has_error_injection(bus)) return -EOPNOTSUPP; if (!ndctl_bus_has_nfit(bus)) return -EOPNOTSUPP; for (i = 0; i < count; i++) { rc = ndctl_namespace_inject_one_error(ndns, block + i, flags); if (rc) { err(ctx, "Injection failed at block %llx\n", block + i); return rc; } } return rc; } NDCTL_EXPORT int ndctl_namespace_inject_error(struct ndctl_namespace *ndns, unsigned long long block, unsigned long long count, bool notify) { return ndctl_namespace_inject_error2(ndns, block, count, notify ? (1 << NDCTL_NS_INJECT_NOTIFY) : 0); } static int ndctl_namespace_uninject_one_error(struct ndctl_namespace *ndns, unsigned long long block, unsigned int flags) { struct ndctl_bus *bus = ndctl_namespace_get_bus(ndns); struct ndctl_ctx *ctx = ndctl_bus_get_ctx(bus); struct nd_cmd_ars_err_inj_clr *err_inj_clr; struct nd_cmd_pkg *pkg; struct ndctl_cmd *cmd; u64 offset, length; int rc, clear_unit; rc = block_to_spa_offset(ndns, block, 1, &offset, &length); if (rc) return rc; clear_unit = ndctl_namespace_get_clear_unit(ndns); if (clear_unit < 0) return clear_unit; if (!(flags & (1 << NDCTL_NS_INJECT_SATURATE))) { /* clamp injection length per block to the clear_unit */ if (length > (unsigned int)clear_unit) length = clear_unit; } cmd = ndctl_bus_cmd_new_err_inj_clr(bus); if (!cmd) return -ENOMEM; pkg = (struct nd_cmd_pkg *)&cmd->cmd_buf[0]; err_inj_clr = (struct nd_cmd_ars_err_inj_clr *)&pkg->nd_payload[0]; err_inj_clr->err_inj_clr_spa_range_base = offset; err_inj_clr->err_inj_clr_spa_range_length = length; rc = ndctl_cmd_submit(cmd); if (rc) { dbg(ctx, "Error submitting command: %d\n", rc); goto out; } rc = translate_status(err_inj_clr->status); out: ndctl_cmd_unref(cmd); return rc; } NDCTL_EXPORT int ndctl_namespace_uninject_error2(struct ndctl_namespace *ndns, unsigned long long block, unsigned long long count, unsigned int flags) { struct ndctl_bus *bus = ndctl_namespace_get_bus(ndns); struct ndctl_ctx *ctx = ndctl_bus_get_ctx(bus); unsigned long long i; int rc = -EINVAL; if (!ndctl_bus_has_error_injection(bus)) return -EOPNOTSUPP; if (!ndctl_bus_has_nfit(bus)) return -EOPNOTSUPP; for (i = 0; i < count; i++) { rc = ndctl_namespace_uninject_one_error(ndns, block + i, flags); if (rc) { err(ctx, "Un-injection failed at block %llx\n", block + i); return rc; } } return rc; } NDCTL_EXPORT int ndctl_namespace_uninject_error(struct ndctl_namespace *ndns, unsigned long long block, unsigned long long count) { return ndctl_namespace_uninject_error2(ndns, block, count, 0); } static int bb_add_record(struct list_head *h, u64 block, u64 count) { struct ndctl_bb *bb, *bb_iter, *bb_next, *bb_prev; int merged = 0; bb = calloc(1, sizeof(*bb)); if (bb == NULL) return -ENOMEM; bb->block = block; bb->count = count; if (list_empty(h)) { list_add(h, &bb->list); return 0; } /* add 'bb' to the list such that it remains sorted */ list_for_each(h, bb_iter, list) { /* Find insertion point */ bb_prev = list_prev(h, bb_iter, list); bb_next = list_next(h, bb_iter, list); if (bb_prev == NULL) { /* bb_iter is the first entry */ if (bb->block < bb_iter->block) { list_add(h, &bb->list); bb = NULL; break; } } if (bb_next == NULL) { /* * bb_iter is the last entry. If we've reached here, * the only option is to add to the tail as the case * for "tail - 1" should have been covered by the * following checks for the previous iteration. */ list_add_tail(h, &bb->list); bb = NULL; break; } /* Add to the left of bb_iter */ if (bb->block <= bb_iter->block) { if (bb_prev && (bb_prev->block <= bb->block)) { list_add_after(h, &bb_prev->list, &bb->list); bb = NULL; break; } } /* Add to the right of bb_iter */ if (bb_iter->block <= bb->block) { if (bb_next && (bb->block <= bb_next->block)) { list_add_after(h, &bb_iter->list, &bb->list); bb = NULL; break; } } } /* ensure bb has actually been consumed (set to NULL earlier) */ if (bb != NULL) { free(bb); return -ENXIO; } /* second pass over the list looking for mergeable entries */ list_for_each(h, bb_iter, list) { u64 cur_end, next_end, cur_start, next_start; /* * test for merges in a loop here because one addition can * potentially have a cascading merge effect on multiple * remaining entries */ do { /* reset the merged flag */ merged = 0; bb_next = list_next(h, bb_iter, list); if (bb_next == NULL) break; cur_start = bb_iter->block; next_start = bb_next->block; cur_end = bb_iter->block + bb_iter->count - 1; next_end = bb_next->block + bb_next->count - 1; if (cur_end >= next_start) { /* overlapping records that can be merged */ if (next_end > cur_end) { /* next extends cur */ bb_iter->count = next_end - cur_start + 1; } else { /* next is contained in cur */ ; } /* next is now redundant */ list_del_from(h, &bb_next->list); free(bb_next); merged = 1; continue; } if (next_start == cur_end + 1) { /* adjoining records that can be merged */ bb_iter->count = next_end - cur_start + 1; list_del_from(h, &bb_next->list); free(bb_next); merged = 1; continue; } } while (merged); } return 0; } static int injection_status_to_bb(struct ndctl_namespace *ndns, struct nd_cmd_ars_err_inj_stat *stat, u64 ns_spa, u64 ns_size) { unsigned int i; int rc = 0; for (i = 0; i < stat->inj_err_rec_count; i++) { u64 ns_off, rec_off, rec_len; u64 block, count, start_pad; rec_off = stat->record[i].err_inj_stat_spa_range_base; rec_len = stat->record[i].err_inj_stat_spa_range_length; /* discard ranges outside the provided namespace */ if (rec_off < ns_spa) continue; if (rec_off >= ns_spa + ns_size) continue; /* translate spa offset to namespace offset */ ns_off = rec_off - ns_spa; block = ALIGN_DOWN(ns_off, 512)/512; start_pad = ns_off - (block * 512); count = ALIGN(start_pad + rec_len, 512)/512; rc = bb_add_record(&ndns->injected_bb, block, count); if (rc) break; } return rc; } NDCTL_EXPORT int ndctl_namespace_injection_status(struct ndctl_namespace *ndns) { struct ndctl_bus *bus = ndctl_namespace_get_bus(ndns); struct ndctl_ctx *ctx = ndctl_bus_get_ctx(bus); struct nd_cmd_ars_err_inj_stat *err_inj_stat; unsigned long long ns_offset, ns_size; int rc = -EOPNOTSUPP, buf_size; struct ndctl_cmd *cmd = NULL; struct nd_cmd_pkg *pkg; if (!ndctl_bus_has_error_injection(bus)) return -EOPNOTSUPP; if (ndctl_bus_has_nfit(bus)) { ndctl_namespace_get_injection_bounds(ndns, &ns_offset, &ns_size); cmd = ndctl_bus_cmd_new_ars_cap(bus, ns_offset, ns_size); rc = ndctl_cmd_submit(cmd); if (rc) { dbg(ctx, "Error submitting ars_cap: %d\n", rc); goto out; } buf_size = ndctl_cmd_ars_cap_get_size(cmd); if (buf_size == 0) { dbg(ctx, "Got an invalid max_ars_out from ars_cap\n"); rc = -EINVAL; goto out; } ndctl_cmd_unref(cmd); cmd = ndctl_bus_cmd_new_err_inj_stat(bus, buf_size); if (!cmd) return -ENOMEM; pkg = (struct nd_cmd_pkg *)&cmd->cmd_buf[0]; err_inj_stat = (struct nd_cmd_ars_err_inj_stat *)&pkg->nd_payload[0]; rc = ndctl_cmd_submit(cmd); if (rc) { dbg(ctx, "Error submitting command: %d\n", rc); goto out; } rc = injection_status_to_bb(ndns, err_inj_stat, ns_offset, ns_size); if (rc) { dbg(ctx, "Error converting status to badblocks: %d\n", rc); goto out; } } out: ndctl_cmd_unref(cmd); return rc; } NDCTL_EXPORT struct ndctl_bb *ndctl_namespace_injection_get_first_bb( struct ndctl_namespace *ndns) { return list_top(&ndns->injected_bb, struct ndctl_bb, list); } NDCTL_EXPORT struct ndctl_bb *ndctl_namespace_injection_get_next_bb( struct ndctl_namespace *ndns, struct ndctl_bb *bb) { return list_next(&ndns->injected_bb, bb, list); } NDCTL_EXPORT unsigned long long ndctl_bb_get_block(struct ndctl_bb *bb) { if (bb) return bb->block; return ULLONG_MAX; } NDCTL_EXPORT unsigned long long ndctl_bb_get_count(struct ndctl_bb *bb) { if (bb) return bb->count; return ULLONG_MAX; } ndctl-61.2/ndctl/lib/intel.c000066400000000000000000000516351331777607200157260ustar00rootroot00000000000000/* * Copyright (c) 2016-2017, Intel Corporation. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU Lesser General Public License, * version 2.1, as published by the Free Software Foundation. * * This program is distributed in the hope 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. */ #include #include #include #include #include "private.h" static struct ndctl_cmd *alloc_intel_cmd(struct ndctl_dimm *dimm, unsigned func, size_t in_size, size_t out_size) { struct ndctl_ctx *ctx = ndctl_dimm_get_ctx(dimm); struct ndctl_cmd *cmd; size_t size; if (!ndctl_dimm_is_cmd_supported(dimm, ND_CMD_CALL)) { dbg(ctx, "unsupported cmd: %d\n", ND_CMD_CALL); return NULL; } if (test_dimm_dsm(dimm, func) == DIMM_DSM_UNSUPPORTED) { dbg(ctx, "unsupported function: %d\n", func); return NULL; } size = sizeof(*cmd) + sizeof(struct nd_pkg_intel) + in_size + out_size; cmd = calloc(1, size); if (!cmd) return NULL; cmd->dimm = dimm; ndctl_cmd_ref(cmd); cmd->type = ND_CMD_CALL; cmd->size = size; cmd->status = 1; *(cmd->intel) = (struct nd_pkg_intel) { .gen = { .nd_family = NVDIMM_FAMILY_INTEL, .nd_command = func, .nd_size_in = in_size, .nd_size_out = out_size, }, }; return cmd; } static struct ndctl_cmd *intel_dimm_cmd_new_smart(struct ndctl_dimm *dimm) { struct ndctl_cmd *cmd; BUILD_ASSERT(sizeof(struct nd_intel_smart) == 132); cmd = alloc_intel_cmd(dimm, ND_INTEL_SMART, 0, sizeof(cmd->intel->smart)); if (!cmd) return NULL; cmd->firmware_status = &cmd->intel->smart.status; return cmd; } static int intel_smart_valid(struct ndctl_cmd *cmd) { struct nd_pkg_intel *pkg = cmd->intel; if (cmd->type != ND_CMD_CALL || cmd->status != 0 || pkg->gen.nd_family != NVDIMM_FAMILY_INTEL || pkg->gen.nd_command != ND_INTEL_SMART) return cmd->status < 0 ? cmd->status : -EINVAL; return 0; } #define intel_smart_get_field(cmd, field) \ static unsigned int intel_cmd_smart_get_##field(struct ndctl_cmd *cmd) \ { \ if (intel_smart_valid(cmd) < 0) \ return UINT_MAX; \ return cmd->intel->smart.field; \ } static unsigned int intel_cmd_smart_get_flags(struct ndctl_cmd *cmd) { unsigned int flags = 0; unsigned int intel_flags; if (intel_smart_valid(cmd) < 0) return 0; /* translate intel specific flags to libndctl api smart flags */ intel_flags = cmd->intel->smart.flags; if (intel_flags & ND_INTEL_SMART_HEALTH_VALID) flags |= ND_SMART_HEALTH_VALID; if (intel_flags & ND_INTEL_SMART_SPARES_VALID) flags |= ND_SMART_SPARES_VALID; if (intel_flags & ND_INTEL_SMART_USED_VALID) flags |= ND_SMART_USED_VALID; if (intel_flags & ND_INTEL_SMART_MTEMP_VALID) flags |= ND_SMART_MTEMP_VALID; if (intel_flags & ND_INTEL_SMART_CTEMP_VALID) flags |= ND_SMART_CTEMP_VALID; if (intel_flags & ND_INTEL_SMART_SHUTDOWN_COUNT_VALID) flags |= ND_SMART_SHUTDOWN_COUNT_VALID; if (intel_flags & ND_INTEL_SMART_AIT_STATUS_VALID) flags |= ND_SMART_AIT_STATUS_VALID; if (intel_flags & ND_INTEL_SMART_PTEMP_VALID) flags |= ND_SMART_PTEMP_VALID; if (intel_flags & ND_INTEL_SMART_ALARM_VALID) flags |= ND_SMART_ALARM_VALID; if (intel_flags & ND_INTEL_SMART_SHUTDOWN_VALID) flags |= ND_SMART_SHUTDOWN_VALID; if (intel_flags & ND_INTEL_SMART_VENDOR_VALID) flags |= ND_SMART_VENDOR_VALID; return flags; } static unsigned int intel_cmd_smart_get_health(struct ndctl_cmd *cmd) { unsigned int health = 0; unsigned int intel_health; if (intel_smart_valid(cmd) < 0) return 0; intel_health = cmd->intel->smart.health; if (intel_health & ND_INTEL_SMART_NON_CRITICAL_HEALTH) health |= ND_SMART_NON_CRITICAL_HEALTH; if (intel_health & ND_INTEL_SMART_CRITICAL_HEALTH) health |= ND_SMART_CRITICAL_HEALTH; if (intel_health & ND_INTEL_SMART_FATAL_HEALTH) health |= ND_SMART_FATAL_HEALTH; return health; } intel_smart_get_field(cmd, media_temperature) intel_smart_get_field(cmd, ctrl_temperature) intel_smart_get_field(cmd, spares) intel_smart_get_field(cmd, alarm_flags) intel_smart_get_field(cmd, life_used) intel_smart_get_field(cmd, shutdown_state) intel_smart_get_field(cmd, shutdown_count) intel_smart_get_field(cmd, vendor_size) static unsigned char *intel_cmd_smart_get_vendor_data(struct ndctl_cmd *cmd) { if (intel_smart_valid(cmd) < 0) return NULL; return cmd->intel->smart.vendor_data; } static int intel_smart_threshold_valid(struct ndctl_cmd *cmd) { struct nd_pkg_intel *pkg = cmd->intel; if (cmd->type != ND_CMD_CALL || cmd->status != 0 || pkg->gen.nd_family != NVDIMM_FAMILY_INTEL || pkg->gen.nd_command != ND_INTEL_SMART_THRESHOLD) return cmd->status < 0 ? cmd->status : -EINVAL; return 0; } #define intel_smart_threshold_get_field(cmd, field) \ static unsigned int intel_cmd_smart_threshold_get_##field( \ struct ndctl_cmd *cmd) \ { \ if (intel_smart_threshold_valid(cmd) < 0) \ return UINT_MAX; \ return cmd->intel->thresh.field; \ } static unsigned int intel_cmd_smart_threshold_get_alarm_control( struct ndctl_cmd *cmd) { struct nd_intel_smart_threshold *thresh; unsigned int flags = 0; if (intel_smart_threshold_valid(cmd) < 0) return 0; thresh = &cmd->intel->thresh; if (thresh->alarm_control & ND_INTEL_SMART_SPARE_TRIP) flags |= ND_SMART_SPARE_TRIP; if (thresh->alarm_control & ND_INTEL_SMART_TEMP_TRIP) flags |= ND_SMART_TEMP_TRIP; if (thresh->alarm_control & ND_INTEL_SMART_CTEMP_TRIP) flags |= ND_SMART_CTEMP_TRIP; return flags; } intel_smart_threshold_get_field(cmd, media_temperature) intel_smart_threshold_get_field(cmd, ctrl_temperature) intel_smart_threshold_get_field(cmd, spares) static struct ndctl_cmd *intel_dimm_cmd_new_smart_threshold( struct ndctl_dimm *dimm) { struct ndctl_cmd *cmd; BUILD_ASSERT(sizeof(struct nd_intel_smart_threshold) == 12); cmd = alloc_intel_cmd(dimm, ND_INTEL_SMART_THRESHOLD, 0, sizeof(cmd->intel->thresh)); if (!cmd) return NULL; cmd->firmware_status = &cmd->intel->thresh.status; return cmd; } static struct ndctl_cmd *intel_dimm_cmd_new_smart_set_threshold( struct ndctl_cmd *cmd_thresh) { struct ndctl_cmd *cmd; struct nd_intel_smart_threshold *thresh; struct nd_intel_smart_set_threshold *set_thresh; BUILD_ASSERT(sizeof(struct nd_intel_smart_set_threshold) == 11); if (intel_smart_threshold_valid(cmd_thresh) < 0) return NULL; cmd = alloc_intel_cmd(cmd_thresh->dimm, ND_INTEL_SMART_SET_THRESHOLD, offsetof(typeof(*set_thresh), status), 4); if (!cmd) return NULL; cmd->source = cmd_thresh; ndctl_cmd_ref(cmd_thresh); set_thresh = &cmd->intel->set_thresh; thresh = &cmd_thresh->intel->thresh; set_thresh->alarm_control = thresh->alarm_control; set_thresh->spares = thresh->spares; set_thresh->media_temperature = thresh->media_temperature; set_thresh->ctrl_temperature = thresh->ctrl_temperature; cmd->firmware_status = &set_thresh->status; return cmd; } static int intel_smart_set_threshold_valid(struct ndctl_cmd *cmd) { struct nd_pkg_intel *pkg = cmd->intel; if (cmd->type != ND_CMD_CALL || cmd->status != 1 || pkg->gen.nd_family != NVDIMM_FAMILY_INTEL || pkg->gen.nd_command != ND_INTEL_SMART_SET_THRESHOLD) return -EINVAL; return 0; } #define intel_smart_set_threshold_field(field) \ static int intel_cmd_smart_threshold_set_##field( \ struct ndctl_cmd *cmd, unsigned int val) \ { \ if (intel_smart_set_threshold_valid(cmd) < 0) \ return -EINVAL; \ cmd->intel->set_thresh.field = val; \ return 0; \ } static unsigned int intel_cmd_smart_threshold_get_supported_alarms( struct ndctl_cmd *cmd) { if (intel_smart_set_threshold_valid(cmd) < 0) return 0; return ND_SMART_SPARE_TRIP | ND_SMART_MTEMP_TRIP | ND_SMART_CTEMP_TRIP; } intel_smart_set_threshold_field(alarm_control) intel_smart_set_threshold_field(spares) intel_smart_set_threshold_field(media_temperature) intel_smart_set_threshold_field(ctrl_temperature) static int intel_smart_inject_valid(struct ndctl_cmd *cmd) { struct nd_pkg_intel *pkg = cmd->intel; if (cmd->type != ND_CMD_CALL || cmd->status != 1 || pkg->gen.nd_family != NVDIMM_FAMILY_INTEL || pkg->gen.nd_command != ND_INTEL_SMART_INJECT) return cmd->status < 0 ? cmd->status : -EINVAL; return 0; } static struct ndctl_cmd *intel_new_smart_inject(struct ndctl_dimm *dimm) { struct ndctl_cmd *cmd; BUILD_ASSERT(sizeof(struct nd_intel_smart_inject) == 19); cmd = alloc_intel_cmd(dimm, ND_INTEL_SMART_INJECT, offsetof(struct nd_intel_smart_inject, status), 4); if (!cmd) return NULL; cmd->firmware_status = &cmd->intel->inject.status; return cmd; } static int intel_cmd_smart_inject_media_temperature(struct ndctl_cmd *cmd, bool enable, unsigned int mtemp) { struct nd_intel_smart_inject *inj; if (intel_smart_inject_valid(cmd) < 0) return -EINVAL; inj = &cmd->intel->inject; inj->flags |= ND_INTEL_SMART_INJECT_MTEMP; inj->mtemp_enable = enable == true; inj->media_temperature = mtemp; return 0; } static int intel_cmd_smart_inject_spares(struct ndctl_cmd *cmd, bool enable, unsigned int spares) { struct nd_intel_smart_inject *inj; if (intel_smart_inject_valid(cmd) < 0) return -EINVAL; inj = &cmd->intel->inject; inj->flags |= ND_INTEL_SMART_INJECT_SPARE; inj->spare_enable = enable == true; inj->spares = spares; return 0; } static int intel_cmd_smart_inject_fatal(struct ndctl_cmd *cmd, bool enable) { struct nd_intel_smart_inject *inj; if (intel_smart_inject_valid(cmd) < 0) return -EINVAL; inj = &cmd->intel->inject; inj->flags |= ND_INTEL_SMART_INJECT_FATAL; inj->fatal_enable = enable == true; return 0; } static int intel_cmd_smart_inject_unsafe_shutdown(struct ndctl_cmd *cmd, bool enable) { struct nd_intel_smart_inject *inj; if (intel_smart_inject_valid(cmd) < 0) return -EINVAL; inj = &cmd->intel->inject; inj->flags |= ND_INTEL_SMART_INJECT_SHUTDOWN; inj->unsafe_shutdown_enable = enable == true; return 0; } static const char *intel_cmd_desc(int fn) { static const char *descs[] = { [ND_INTEL_SMART] = "smart", [ND_INTEL_SMART_INJECT] = "smart_inject", [ND_INTEL_SMART_THRESHOLD] = "smart_thresh", [ND_INTEL_FW_GET_INFO] = "firmware_get_info", [ND_INTEL_FW_START_UPDATE] = "firmware_start_update", [ND_INTEL_FW_SEND_DATA] = "firmware_send_data", [ND_INTEL_FW_FINISH_UPDATE] = "firmware_finish_update", [ND_INTEL_FW_FINISH_STATUS_QUERY] = "firmware_finish_query", [ND_INTEL_SMART_SET_THRESHOLD] = "smart_set_thresh", }; const char *desc = descs[fn]; if (fn >= (int) ARRAY_SIZE(descs)) return "unknown"; if (!desc) return "unknown"; return desc; } static struct ndctl_cmd *intel_dimm_cmd_new_fw_get_info(struct ndctl_dimm *dimm) { struct ndctl_cmd *cmd; BUILD_ASSERT(sizeof(struct nd_intel_fw_info) == 44); cmd = alloc_intel_cmd(dimm, ND_INTEL_FW_GET_INFO, 0, sizeof(cmd->intel->info)); if (!cmd) return NULL; cmd->firmware_status = &cmd->intel->info.status; return cmd; } static int intel_fw_get_info_valid(struct ndctl_cmd *cmd) { struct nd_pkg_intel *pkg = cmd->intel; if (cmd->type != ND_CMD_CALL || cmd->status != 0 || pkg->gen.nd_family != NVDIMM_FAMILY_INTEL || pkg->gen.nd_command != ND_INTEL_FW_GET_INFO) return -EINVAL; return 0; } #define intel_fw_info_get_field32(cmd, field) \ static unsigned int intel_cmd_fw_info_get_##field( \ struct ndctl_cmd *cmd) \ { \ if (intel_fw_get_info_valid(cmd) < 0) \ return UINT_MAX; \ return cmd->intel->info.field; \ } #define intel_fw_info_get_field64(cmd, field) \ static unsigned long long intel_cmd_fw_info_get_##field( \ struct ndctl_cmd *cmd) \ { \ if (intel_fw_get_info_valid(cmd) < 0) \ return ULLONG_MAX; \ return cmd->intel->info.field; \ } intel_fw_info_get_field32(cmd, storage_size) intel_fw_info_get_field32(cmd, max_send_len) intel_fw_info_get_field32(cmd, query_interval) intel_fw_info_get_field32(cmd, max_query_time); intel_fw_info_get_field64(cmd, run_version); static unsigned long long intel_cmd_fw_info_get_updated_version( struct ndctl_cmd *cmd) { if (intel_fw_get_info_valid(cmd) < 0) return ULLONG_MAX; return cmd->intel->info.updated_version; } static struct ndctl_cmd *intel_dimm_cmd_new_fw_start(struct ndctl_dimm *dimm) { struct ndctl_cmd *cmd; BUILD_ASSERT(sizeof(struct nd_intel_fw_start) == 8); cmd = alloc_intel_cmd(dimm, ND_INTEL_FW_START_UPDATE, 0, sizeof(cmd->intel->start)); if (!cmd) return NULL; cmd->firmware_status = &cmd->intel->start.status; return cmd; } static int intel_fw_start_valid(struct ndctl_cmd *cmd) { struct nd_pkg_intel *pkg = cmd->intel; if (cmd->type != ND_CMD_CALL || cmd->status != 0 || pkg->gen.nd_family != NVDIMM_FAMILY_INTEL || pkg->gen.nd_command != ND_INTEL_FW_START_UPDATE) return -EINVAL; return 0; } static unsigned int intel_cmd_fw_start_get_context(struct ndctl_cmd *cmd) { if (intel_fw_start_valid(cmd) < 0) return UINT_MAX; return cmd->intel->start.context; } static struct ndctl_cmd *intel_dimm_cmd_new_fw_send(struct ndctl_cmd *start, unsigned int offset, unsigned int len, void *data) { struct ndctl_cmd *cmd; BUILD_ASSERT(sizeof(struct nd_intel_fw_send_data) == 12); cmd = alloc_intel_cmd(start->dimm, ND_INTEL_FW_SEND_DATA, sizeof(cmd->intel->send) + len, 4); if (!cmd) return NULL; cmd->intel->send.context = start->intel->start.context; cmd->intel->send.offset = offset; cmd->intel->send.length = len; memcpy(cmd->intel->send.data, data, len); /* the last dword is reserved for status */ cmd->firmware_status = (unsigned int *)(&cmd->intel->send.data[0] + len); return cmd; } static struct ndctl_cmd *intel_dimm_cmd_new_fw_finish(struct ndctl_cmd *start) { struct ndctl_cmd *cmd; BUILD_ASSERT(sizeof(struct nd_intel_fw_finish_update) == 12); cmd = alloc_intel_cmd(start->dimm, ND_INTEL_FW_FINISH_UPDATE, offsetof(struct nd_intel_fw_finish_update, status), 4); if (!cmd) return NULL; cmd->intel->finish.context = start->intel->start.context; cmd->intel->finish.ctrl_flags = 0; cmd->firmware_status = &cmd->intel->finish.status; return cmd; } static struct ndctl_cmd *intel_dimm_cmd_new_fw_abort(struct ndctl_cmd *start) { struct ndctl_cmd *cmd; BUILD_ASSERT(sizeof(struct nd_intel_fw_finish_update) == 12); cmd = alloc_intel_cmd(start->dimm, ND_INTEL_FW_FINISH_UPDATE, sizeof(cmd->intel->finish) - 4, 4); if (!cmd) return NULL; cmd->intel->finish.context = start->intel->start.context; cmd->intel->finish.ctrl_flags = 1; cmd->firmware_status = &cmd->intel->finish.status; return cmd; } static struct ndctl_cmd * intel_dimm_cmd_new_fw_finish_query(struct ndctl_cmd *start) { struct ndctl_cmd *cmd; BUILD_ASSERT(sizeof(struct nd_intel_fw_finish_query) == 16); cmd = alloc_intel_cmd(start->dimm, ND_INTEL_FW_FINISH_STATUS_QUERY, 4, sizeof(cmd->intel->fquery) - 4); if (!cmd) return NULL; cmd->intel->fquery.context = start->intel->start.context; cmd->firmware_status = &cmd->intel->fquery.status; return cmd; } static int intel_fw_fquery_valid(struct ndctl_cmd *cmd) { struct nd_pkg_intel *pkg = cmd->intel; if (cmd->type != ND_CMD_CALL || cmd->status != 0 || pkg->gen.nd_family != NVDIMM_FAMILY_INTEL || pkg->gen.nd_command != ND_INTEL_FW_FINISH_STATUS_QUERY) return -EINVAL; return 0; } static unsigned long long intel_cmd_fw_fquery_get_fw_rev(struct ndctl_cmd *cmd) { if (intel_fw_fquery_valid(cmd) < 0) return ULLONG_MAX; return cmd->intel->fquery.updated_fw_rev; } static enum ND_FW_STATUS intel_cmd_fw_xlat_extend_firmware_status(struct ndctl_cmd *cmd, unsigned int status) { /* * Note: the cases commented out are identical to the ones that are * not. They are there for reference. */ switch (status & ND_INTEL_STATUS_EXTEND_MASK) { case ND_INTEL_STATUS_START_BUSY: /* case ND_INTEL_STATUS_SEND_CTXINVAL: */ /* case ND_INTEL_STATUS_FIN_CTXINVAL: */ /* case ND_INTEL_STATUS_FQ_CTXINVAL: */ if (cmd->intel->gen.nd_command == ND_INTEL_FW_START_UPDATE) return FW_EBUSY; else return FW_EINVAL_CTX; case ND_INTEL_STATUS_FIN_DONE: /* case ND_INTEL_STATUS_FQ_BUSY: */ if (cmd->intel->gen.nd_command == ND_INTEL_FW_FINISH_UPDATE) return FW_ALREADY_DONE; else return FW_EBUSY; case ND_INTEL_STATUS_FIN_BAD: /* case ND_INTEL_STATUS_FQ_BAD: */ return FW_EBADFW; case ND_INTEL_STATUS_FIN_ABORTED: /* case ND_INTEL_STATUS_FQ_ORDER: */ if (cmd->intel->gen.nd_command == ND_INTEL_FW_FINISH_UPDATE) return FW_ABORTED; else return FW_ESEQUENCE; } return FW_EUNKNOWN; } static enum ND_FW_STATUS intel_cmd_fw_xlat_firmware_status(struct ndctl_cmd *cmd) { unsigned int status = *cmd->firmware_status; switch (status & ND_INTEL_STATUS_MASK) { case ND_INTEL_STATUS_SUCCESS: return FW_SUCCESS; case ND_INTEL_STATUS_NOTSUPP: return FW_ENOTSUPP; case ND_INTEL_STATUS_NOTEXIST: return FW_ENOTEXIST; case ND_INTEL_STATUS_INVALPARM: return FW_EINVAL; case ND_INTEL_STATUS_HWERR: return FW_EHWERR; case ND_INTEL_STATUS_RETRY: return FW_ERETRY; case ND_INTEL_STATUS_EXTEND: return intel_cmd_fw_xlat_extend_firmware_status(cmd, status); case ND_INTEL_STATUS_NORES: return FW_ENORES; case ND_INTEL_STATUS_NOTREADY: return FW_ENOTREADY; } return FW_EUNKNOWN; } static struct ndctl_cmd * intel_dimm_cmd_new_lss(struct ndctl_dimm *dimm) { struct ndctl_cmd *cmd; BUILD_ASSERT(sizeof(struct nd_intel_lss) == 5); cmd = alloc_intel_cmd(dimm, ND_INTEL_ENABLE_LSS_STATUS, 1, 4); if (!cmd) return NULL; cmd->intel->lss.enable = 1; cmd->firmware_status = &cmd->intel->lss.status; return cmd; } static int intel_dimm_fw_update_supported(struct ndctl_dimm *dimm) { struct ndctl_ctx *ctx = ndctl_dimm_get_ctx(dimm); if (!ndctl_dimm_is_cmd_supported(dimm, ND_CMD_CALL)) { dbg(ctx, "unsupported cmd: %d\n", ND_CMD_CALL); return -EOPNOTSUPP; } if (test_dimm_dsm(dimm, ND_INTEL_FW_GET_INFO) == DIMM_DSM_UNSUPPORTED || test_dimm_dsm(dimm, ND_INTEL_FW_START_UPDATE) == DIMM_DSM_UNSUPPORTED || test_dimm_dsm(dimm, ND_INTEL_FW_SEND_DATA) == DIMM_DSM_UNSUPPORTED || test_dimm_dsm(dimm, ND_INTEL_FW_FINISH_UPDATE) == DIMM_DSM_UNSUPPORTED || test_dimm_dsm(dimm, ND_INTEL_FW_FINISH_STATUS_QUERY) == DIMM_DSM_UNSUPPORTED) { dbg(ctx, "unsupported function: %d\n", ND_INTEL_FW_GET_INFO); return -EIO; } return 0; } struct ndctl_dimm_ops * const intel_dimm_ops = &(struct ndctl_dimm_ops) { .cmd_desc = intel_cmd_desc, .new_smart = intel_dimm_cmd_new_smart, .smart_get_flags = intel_cmd_smart_get_flags, .smart_get_health = intel_cmd_smart_get_health, .smart_get_media_temperature = intel_cmd_smart_get_media_temperature, .smart_get_ctrl_temperature = intel_cmd_smart_get_ctrl_temperature, .smart_get_spares = intel_cmd_smart_get_spares, .smart_get_alarm_flags = intel_cmd_smart_get_alarm_flags, .smart_get_life_used = intel_cmd_smart_get_life_used, .smart_get_shutdown_state = intel_cmd_smart_get_shutdown_state, .smart_get_shutdown_count = intel_cmd_smart_get_shutdown_count, .smart_get_vendor_size = intel_cmd_smart_get_vendor_size, .smart_get_vendor_data = intel_cmd_smart_get_vendor_data, .new_smart_threshold = intel_dimm_cmd_new_smart_threshold, .smart_threshold_get_alarm_control = intel_cmd_smart_threshold_get_alarm_control, .smart_threshold_get_media_temperature = intel_cmd_smart_threshold_get_media_temperature, .smart_threshold_get_ctrl_temperature = intel_cmd_smart_threshold_get_ctrl_temperature, .smart_threshold_get_spares = intel_cmd_smart_threshold_get_spares, .new_smart_set_threshold = intel_dimm_cmd_new_smart_set_threshold, .smart_threshold_get_supported_alarms = intel_cmd_smart_threshold_get_supported_alarms, .smart_threshold_set_alarm_control = intel_cmd_smart_threshold_set_alarm_control, .smart_threshold_set_media_temperature = intel_cmd_smart_threshold_set_media_temperature, .smart_threshold_set_ctrl_temperature = intel_cmd_smart_threshold_set_ctrl_temperature, .smart_threshold_set_spares = intel_cmd_smart_threshold_set_spares, .new_smart_inject = intel_new_smart_inject, .smart_inject_media_temperature = intel_cmd_smart_inject_media_temperature, .smart_inject_spares = intel_cmd_smart_inject_spares, .smart_inject_fatal = intel_cmd_smart_inject_fatal, .smart_inject_unsafe_shutdown = intel_cmd_smart_inject_unsafe_shutdown, .new_fw_get_info = intel_dimm_cmd_new_fw_get_info, .fw_info_get_storage_size = intel_cmd_fw_info_get_storage_size, .fw_info_get_max_send_len = intel_cmd_fw_info_get_max_send_len, .fw_info_get_query_interval = intel_cmd_fw_info_get_query_interval, .fw_info_get_max_query_time = intel_cmd_fw_info_get_max_query_time, .fw_info_get_run_version = intel_cmd_fw_info_get_run_version, .fw_info_get_updated_version = intel_cmd_fw_info_get_updated_version, .new_fw_start_update = intel_dimm_cmd_new_fw_start, .fw_start_get_context = intel_cmd_fw_start_get_context, .new_fw_send = intel_dimm_cmd_new_fw_send, .new_fw_finish = intel_dimm_cmd_new_fw_finish, .new_fw_abort = intel_dimm_cmd_new_fw_abort, .new_fw_finish_query = intel_dimm_cmd_new_fw_finish_query, .fw_fquery_get_fw_rev = intel_cmd_fw_fquery_get_fw_rev, .fw_xlat_firmware_status = intel_cmd_fw_xlat_firmware_status, .new_ack_shutdown_count = intel_dimm_cmd_new_lss, .fw_update_supported = intel_dimm_fw_update_supported, }; ndctl-61.2/ndctl/lib/intel.h000066400000000000000000000116511331777607200157250ustar00rootroot00000000000000/* SPDX-License-Identifier: LGPL-2.1 */ /* Copyright (c) 2017, Intel Corporation. All rights reserved. */ #ifndef __INTEL_H__ #define __INTEL_H__ #define ND_INTEL_SMART 1 #define ND_INTEL_SMART_THRESHOLD 2 #define ND_INTEL_ENABLE_LSS_STATUS 10 #define ND_INTEL_FW_GET_INFO 12 #define ND_INTEL_FW_START_UPDATE 13 #define ND_INTEL_FW_SEND_DATA 14 #define ND_INTEL_FW_FINISH_UPDATE 15 #define ND_INTEL_FW_FINISH_STATUS_QUERY 16 #define ND_INTEL_SMART_SET_THRESHOLD 17 #define ND_INTEL_SMART_INJECT 18 #define ND_INTEL_SMART_HEALTH_VALID (1 << 0) #define ND_INTEL_SMART_SPARES_VALID (1 << 1) #define ND_INTEL_SMART_USED_VALID (1 << 2) #define ND_INTEL_SMART_MTEMP_VALID (1 << 3) #define ND_INTEL_SMART_CTEMP_VALID (1 << 4) #define ND_INTEL_SMART_SHUTDOWN_COUNT_VALID (1 << 5) #define ND_INTEL_SMART_AIT_STATUS_VALID (1 << 6) #define ND_INTEL_SMART_PTEMP_VALID (1 << 7) #define ND_INTEL_SMART_ALARM_VALID (1 << 9) #define ND_INTEL_SMART_SHUTDOWN_VALID (1 << 10) #define ND_INTEL_SMART_VENDOR_VALID (1 << 11) #define ND_INTEL_SMART_SPARE_TRIP (1 << 0) #define ND_INTEL_SMART_TEMP_TRIP (1 << 1) #define ND_INTEL_SMART_CTEMP_TRIP (1 << 2) #define ND_INTEL_SMART_NON_CRITICAL_HEALTH (1 << 0) #define ND_INTEL_SMART_CRITICAL_HEALTH (1 << 1) #define ND_INTEL_SMART_FATAL_HEALTH (1 << 2) #define ND_INTEL_SMART_INJECT_MTEMP (1 << 0) #define ND_INTEL_SMART_INJECT_SPARE (1 << 1) #define ND_INTEL_SMART_INJECT_FATAL (1 << 2) #define ND_INTEL_SMART_INJECT_SHUTDOWN (1 << 3) struct nd_intel_smart { __u32 status; union { struct { __u32 flags; __u8 reserved0[4]; __u8 health; __u8 spares; __u8 life_used; __u8 alarm_flags; __u16 media_temperature; __u16 ctrl_temperature; __u32 shutdown_count; __u8 ait_status; __u16 pmic_temperature; __u8 reserved1[8]; __u8 shutdown_state; __u32 vendor_size; __u8 vendor_data[92]; } __attribute__((packed)); __u8 data[128]; }; } __attribute__((packed)); struct nd_intel_smart_threshold { __u32 status; union { struct { __u16 alarm_control; __u8 spares; __u16 media_temperature; __u16 ctrl_temperature; __u8 reserved[1]; } __attribute__((packed)); __u8 data[8]; }; } __attribute__((packed)); struct nd_intel_smart_set_threshold { __u16 alarm_control; __u8 spares; __u16 media_temperature; __u16 ctrl_temperature; __u32 status; } __attribute__((packed)); struct nd_intel_smart_inject { __u64 flags; __u8 mtemp_enable; __u16 media_temperature; __u8 spare_enable; __u8 spares; __u8 fatal_enable; __u8 unsafe_shutdown_enable; __u32 status; } __attribute__((packed)); struct nd_intel_fw_info { __u32 status; __u32 storage_size; __u32 max_send_len; __u32 query_interval; __u32 max_query_time; __u8 update_cap; __u8 reserved[3]; __u32 fis_version; __u64 run_version; __u64 updated_version; } __attribute__((packed)); struct nd_intel_fw_start { __u32 status; __u32 context; } __attribute__((packed)); /* this one has the output first because the variable input data size */ struct nd_intel_fw_send_data { __u32 context; __u32 offset; __u32 length; __u8 data[0]; /* reserving last 4 bytes as status */ /* __u32 status; */ } __attribute__((packed)); struct nd_intel_fw_finish_update { __u8 ctrl_flags; __u8 reserved[3]; __u32 context; __u32 status; } __attribute__((packed)); struct nd_intel_fw_finish_query { __u32 context; __u32 status; __u64 updated_fw_rev; } __attribute__((packed)); struct nd_intel_lss { __u8 enable; __u32 status; } __attribute__((packed)); struct nd_pkg_intel { struct nd_cmd_pkg gen; union { struct nd_intel_smart smart; struct nd_intel_smart_inject inject; struct nd_intel_smart_threshold thresh; struct nd_intel_smart_set_threshold set_thresh; struct nd_intel_fw_info info; struct nd_intel_fw_start start; struct nd_intel_fw_send_data send; struct nd_intel_fw_finish_update finish; struct nd_intel_fw_finish_query fquery; struct nd_intel_lss lss; }; }; #define ND_INTEL_STATUS_MASK 0xffff #define ND_INTEL_STATUS_SUCCESS 0 #define ND_INTEL_STATUS_NOTSUPP 1 #define ND_INTEL_STATUS_NOTEXIST 2 #define ND_INTEL_STATUS_INVALPARM 3 #define ND_INTEL_STATUS_HWERR 4 #define ND_INTEL_STATUS_RETRY 5 #define ND_INTEL_STATUS_UNKNOWN 6 #define ND_INTEL_STATUS_EXTEND 7 #define ND_INTEL_STATUS_NORES 8 #define ND_INTEL_STATUS_NOTREADY 9 #define ND_INTEL_STATUS_EXTEND_MASK 0xffff0000 #define ND_INTEL_STATUS_START_BUSY 0x10000 #define ND_INTEL_STATUS_SEND_CTXINVAL 0x10000 #define ND_INTEL_STATUS_FIN_CTXINVAL 0x10000 #define ND_INTEL_STATUS_FIN_DONE 0x20000 #define ND_INTEL_STATUS_FIN_BAD 0x30000 #define ND_INTEL_STATUS_FIN_ABORTED 0x40000 #define ND_INTEL_STATUS_FQ_CTXINVAL 0x10000 #define ND_INTEL_STATUS_FQ_BUSY 0x20000 #define ND_INTEL_STATUS_FQ_BAD 0x30000 #define ND_INTEL_STATUS_FQ_ORDER 0x40000 #endif /* __INTEL_H__ */ ndctl-61.2/ndctl/lib/libndctl.c000066400000000000000000003634521331777607200164110ustar00rootroot00000000000000/* * Copyright (c) 2014-2016, Intel Corporation. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU Lesser General Public License, * version 2.1, as published by the Free Software Foundation. * * This program is distributed in the hope 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. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "private.h" static uuid_t null_uuid; /** * DOC: General note, the structure layouts are privately defined. * Access struct member fields with ndctl_