diff options
743 files changed, 51081 insertions, 0 deletions
diff --git a/.github/workflows/doc.yml b/.github/workflows/doc.yml new file mode 100644 index 0000000..75afbc8 --- /dev/null +++ b/.github/workflows/doc.yml @@ -0,0 +1,21 @@ +name: libnvme documenation CI + +on: + push: + branches: [ master ] + pull_request: + branches: [ master ] + +jobs: + kernel_doc_job: + runs-on: ubuntu-latest + steps: + - name: Check out repository code + uses: actions/checkout@v2 + - name: Check documentation format + run: | + API_FILES="fabrics.h filters.h ioctl.h linux.h tree.h types.h" + for file in $API_FILES; do + ./doc/kernel-doc -v -none src/nvme/$file 2>&1 | sed -r 's/^([^:]+):([0-9]+): (warning|error):/::\3 file=\1,line=\2::/g' + done + shell: bash diff --git a/.github/workflows/meson.yml b/.github/workflows/meson.yml new file mode 100644 index 0000000..c89de99 --- /dev/null +++ b/.github/workflows/meson.yml @@ -0,0 +1,69 @@ +name: libnvme meson CI + +on: + push: + branches: [ master ] + pull_request: + branches: [ master ] + + workflow_dispatch: + +jobs: + build-disto: + runs-on: ubuntu-latest + steps: + - name: install libraries + run: sudo apt-get install libjson-c-dev + - uses: actions/checkout@v2 + - uses: actions/setup-python@v1 + - uses: BSFishy/meson-build@v1.0.3 + with: + setup-options: --werror + options: --verbose + action: test + # Preserve meson's log file on failure + - uses: actions/upload-artifact@v1 + if: failure() + with: + name: Linux_Meson_Testlog + path: build/meson-logs/testlog.txt + + build-fallback: + runs-on: ubuntu-latest + steps: + - name: install libraries + run: sudo apt-get remove -y libssl-dev + - uses: actions/checkout@v2 + - uses: actions/setup-python@v1 + - uses: BSFishy/meson-build@v1.0.3 + with: + setup-options: --werror + options: --verbose + action: test + meson-version: 0.61.2 + # Preserve meson's log file on failure + - uses: actions/upload-artifact@v1 + if: failure() + with: + name: Linux_Meson_log + path: build/meson-logs/meson-log.txt + + code-coverage: + runs-on: ubuntu-latest + steps: + - name: install libraries + run: sudo apt-get install libjson-c-dev lcov + - uses: actions/checkout@v2 + - uses: actions/setup-python@v1 + - uses: BSFishy/meson-build@v1.0.3 + with: + setup-options: -Db_coverage=true --werror + options: --verbose + # Can't use 'coverage' here, see https://github.com/BSFishy/meson-build/issues/4 + action: test + - name: Generate Coverage Report + # Can't use meson here, see https://github.com/mesonbuild/meson/issues/7895 + run: ninja -C build coverage --verbose + - uses: codecov/codecov-action@v1 + with: + fail_ci_if_error: false diff --git a/.github/workflows/python-publish.yml b/.github/workflows/python-publish.yml new file mode 100644 index 0000000..7e451ef --- /dev/null +++ b/.github/workflows/python-publish.yml @@ -0,0 +1,67 @@ +# This workflow will upload a Python Package using Twine when a release is created +# For more information see: https://help.github.com/en/actions/language-and-framework-guides/using-python-with-github-actions#publishing-to-package-registries + +# This workflow uses actions that are not certified by GitHub. +# They are provided by a third-party and are governed by +# separate terms of service, privacy policy, and support +# documentation. + +name: Build and upload to PyPI + +on: + push: + branches: [ master ] + pull_request: + branches: [ master ] + workflow_dispatch: + +jobs: + build_wheels: + name: Build wheels manylinux + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + + - name: Build wheels + uses: pypa/cibuildwheel@v2.3.1 + env: + CIBW_REPAIR_WHEEL_COMMAND_LINUX: "" + CIBW_SKIP: "*-musllinux_*" + CIBW_BEFORE_BUILD_LINUX: yum install -y openssl-devel libuuid-devel json-c-devel + CIBW_BUILD_VERBOSITY: 1 + + - uses: actions/upload-artifact@v2 + with: + path: ./wheelhouse/*.whl + retention-days: 5 + + build_sdist: + name: Build source distribution + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + + - name: Build sdist + run: pipx run build --sdist + + - uses: actions/upload-artifact@v2 + with: + path: dist/*.tar.gz + retention-days: 5 + + upload_pypi: + needs: [build_wheels, build_sdist] + runs-on: ubuntu-latest + if: github.event_name == 'release' && github.event.action == 'published' + steps: + - uses: actions/download-artifact@v2 + with: + name: artifact + path: dist + + - name: Publish package to TestPyPI + uses: pypa/gh-action-pypi-publish@release/v1 + with: + user: __token__ + password: ${{ secrets.TEST_PYPI_API_TOKEN }} + repository_url: https://test.pypi.org/legacy/ diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..2b640a0 --- /dev/null +++ b/.gitignore @@ -0,0 +1,15 @@ +a.out +*.o +*.ol +*.os +*~ +*.swp +*.a +*.so.* + +cscope.* + +.build + +subprojects/* +!subprojects/*.wrap @@ -0,0 +1,502 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + <one line to give the library's name and a brief idea of what it does.> + Copyright (C) <year> <name of author> + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + <signature of Ty Coon>, 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..3e0e157 --- /dev/null +++ b/Makefile @@ -0,0 +1,43 @@ +# SPDX-License-Identifier: LGPL-2.1-or-later +# +# This file is part of libnvme. +# Copyright (c) 2021 Dell Inc. +# +# Authors: Martin Belanger <Martin.Belanger@dell.com> +# +NAME := libnvme +.DEFAULT_GOAL := ${NAME} +BUILD-DIR := .build + +${BUILD-DIR}: + meson $@ + @echo "Configuration located in: $@" + @echo "-------------------------------------------------------" + +.PHONY: ${NAME} +${NAME}: ${BUILD-DIR} + ninja -C ${BUILD-DIR} + +.PHONY: clean +clean: +ifneq ("$(wildcard ${BUILD-DIR})","") + ninja -C ${BUILD-DIR} -t $@ +endif + +.PHONY: purge +purge: +ifneq ("$(wildcard ${BUILD-DIR})","") + rm -rf ${BUILD-DIR} +endif + +.PHONY: install dist +install dist: ${BUILD-DIR} + cd ${BUILD-DIR} && meson $@ + +.PHONY: test +test: ${BUILD-DIR} + ninja -C ${BUILD-DIR} $@ + +.PHONY: rpm +rpm: dist + rpmbuild -ba ${BUILD-DIR}/libnvme.spec diff --git a/README.md b/README.md new file mode 100644 index 0000000..6871238 --- /dev/null +++ b/README.md @@ -0,0 +1,188 @@ +# libnvme + + + +[](https://pypi.org/project/libnvme/) +[](https://pypi.org/project/libnvme/) + +[](https://codecov.io/gh/linux-nvme/libnvme) +[](https://libnvme.readthedocs.io/en/latest/) + +This is the libnvme development C library. libnvme provides type +definitions for NVMe specification structures, enumerations, and bit +fields, helper functions to construct, dispatch, and decode commands +and payloads, and utilities to connect, scan, and manage nvme devices +on a Linux system. + +The public specification is the authority to resolve any protocol +discrepencies with this library. For more info on NVM Express, please +see: + + http://nvmexpress.org + +Subscribe to linux-nvme@lists.infradead.org for linux-nvme related +discussions and development for both kernel and userspace. The list is +archived here: + + http://lists.infradead.org/mailman/listinfo/linux-nvme + +# License + +Except where otherwise stated, all software contained within this repo +is currently licensed LGPL, see COPYING for more information. + +Keith Busch 2020-02-06 + +------ + +# Building with meson + +## What is the meson build system? + +Here's an excerpt from the meson web site: *Meson is **an open source +build system** meant to be both extremely fast, and, even more +importantly, as user friendly as possible. The main design point of +Meson is that every moment a developer spends writing or debugging +build definitions is a second wasted.* + +Several well-known projects such as `systemd` and `Gnome` use meson as +their build system. A summary of projects using meson can be found +[here](https://mesonbuild.com/Users.html). For more info on meson, +please consult the following sites: + +**Wiki page**: https://en.wikipedia.org/wiki/Meson_(software) + +**meson documentation**: https://mesonbuild.com/ + +**meson repo**: https://github.com/mesonbuild/meson + +## Prerequisite + +First, install meson. + +**Debian / Ubuntu**: + +```bash +sudo apt-get install meson +``` + +**Fedora / Red Hat**: + +```bash +sudo dnf install meson +``` + +## To compile libnvme + +Using meson is similar to projects that use a `configure` script before running `make`. + +To `configure` the project: + +``` +meson .build +``` + +Which will default to build a shared library. To configure for static libraries call + +``` +meson .build --default-library=static +``` + +One nice feature of meson is that it doesn't mix build artifacts +(e.g. `*.o`, `*.so`, etc.) with source code. In the above example, +"`.build`" is the name of the directory where the build configuration +as well as all the build artifacts will be saved. This directory can +be named anything as long as it's not an existing source directory. To +completely "clean" all the build artifacts, one need only delete the +`.build` directory. + +To compile: + +``` +cd .build +ninja +``` + +Or: + +``` +ninja -C .build +``` + +## To install libnvme + +To install `libnvme`: + +``` +cd .build +meson install +``` + +## To run unit tests + +To run unit tests: + +``` +cd .build +meson test +``` + +## To clean after a build + +To perform the equivalent of a `make clean` without deleting the build configuration. + +``` +cd .build +ninja -t clean +``` + +Or: + +``` +ninja -C .build -t clean +``` + +## To purge everything + +To completely clean all build artifacts, including the build configuration. + +``` +rm -rf .build +``` + +## Supported build options + +A few build options can be specified on the command line when invoking meson. + +| Option | Values [default] | Description | +| ------ | ------------------- | ------------------------------------------------------------ | +| man | true, [false] | Instruct meson to configure the project to build the `libnvme` documentation. <br />Example: `meson .build -Dman=true` | +| python | [auto], true, false | Whether to build the Python bindings. When set to `auto`, the default, meson will check for the presence of the tools and libraries (e.g. `swig`) required to build the Python bindings. If found, meson will configure the project to build the Python bindings. If a tool or library is missing, then the Python bindings won't be built. Setting this to `true`, forces the Python bindings to be built. When set to `false`, meson will configure the project to not build the Python bindings.<br />Example: `meson .build -Dpython=false` | + +### Changing the build options from the command-line (i.e. w/o modifying any files) + +To configure a build for debugging purposes (i.e. optimization turned +off and debug symbols enabled): + +```bash +meson .build -Dbuildtype=debug +``` + +To enable address sanitizer (advanced debugging of memory issues): + +```bash +meson .build -Db_sanitize=address +``` + +This option adds `-fsanitize=address` to the gcc options. Note that when using the sanitize feature, the library `libasan.so` must be available and must be the very first library loaded when running an executable. Ensuring that `libasan.so` gets loaded first can be achieved with the `LD_PRELOAD` environment variable as follows: + +``` +meson .build -Db_sanitize=address && LD_PRELOAD=/lib64/libasan.so.6 ninja -C .build test +``` + +To list configuration options that are available and possible values: + +```bash +meson configure .build +``` + diff --git a/ccan/ccan/array_size/LICENSE b/ccan/ccan/array_size/LICENSE new file mode 120000 index 0000000..b7951da --- /dev/null +++ b/ccan/ccan/array_size/LICENSE @@ -0,0 +1 @@ +../../licenses/CC0
\ No newline at end of file diff --git a/ccan/ccan/array_size/_info b/ccan/ccan/array_size/_info new file mode 100644 index 0000000..69570f3 --- /dev/null +++ b/ccan/ccan/array_size/_info @@ -0,0 +1,46 @@ +#include "config.h" +#include <stdio.h> +#include <string.h> + +/** + * array_size - routine for safely deriving the size of a visible array. + * + * This provides a simple ARRAY_SIZE() macro, which (given a good compiler) + * will also break compile if you try to use it on a pointer. + * + * This can ensure your code is robust to changes, without needing a gratuitous + * macro or constant. + * + * Example: + * // Outputs "Initialized 32 values\n" + * #include <ccan/array_size/array_size.h> + * #include <stdlib.h> + * #include <stdio.h> + * + * // We currently use 32 random values. + * static unsigned int vals[32]; + * + * int main(void) + * { + * unsigned int i; + * for (i = 0; i < ARRAY_SIZE(vals); i++) + * vals[i] = random(); + * printf("Initialized %u values\n", i); + * return 0; + * } + * + * License: CC0 (Public domain) + * Author: Rusty Russell <rusty@rustcorp.com.au> + */ +int main(int argc, char *argv[]) +{ + if (argc != 2) + return 1; + + if (strcmp(argv[1], "depends") == 0) { + printf("ccan/build_assert\n"); + return 0; + } + + return 1; +} diff --git a/ccan/ccan/array_size/array_size.h b/ccan/ccan/array_size/array_size.h new file mode 100644 index 0000000..0ca422a --- /dev/null +++ b/ccan/ccan/array_size/array_size.h @@ -0,0 +1,26 @@ +/* CC0 (Public domain) - see LICENSE file for details */ +#ifndef CCAN_ARRAY_SIZE_H +#define CCAN_ARRAY_SIZE_H +#include "config.h" +#include <ccan/build_assert/build_assert.h> + +/** + * 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 */ diff --git a/ccan/ccan/build_assert/LICENSE b/ccan/ccan/build_assert/LICENSE new file mode 120000 index 0000000..b7951da --- /dev/null +++ b/ccan/ccan/build_assert/LICENSE @@ -0,0 +1 @@ +../../licenses/CC0
\ No newline at end of file diff --git a/ccan/ccan/build_assert/_info b/ccan/ccan/build_assert/_info new file mode 100644 index 0000000..97ebe6c --- /dev/null +++ b/ccan/ccan/build_assert/_info @@ -0,0 +1,49 @@ +#include "config.h" +#include <stdio.h> +#include <string.h> + +/** + * build_assert - routines for build-time assertions + * + * This code provides routines which will cause compilation to fail should some + * assertion be untrue: such failures are preferable to run-time assertions, + * but much more limited since they can only depends on compile-time constants. + * + * These assertions are most useful when two parts of the code must be kept in + * sync: it is better to avoid such cases if possible, but seconds best is to + * detect invalid changes at build time. + * + * For example, a tricky piece of code might rely on a certain element being at + * the start of the structure. To ensure that future changes don't break it, + * you would catch such changes in your code like so: + * + * Example: + * #include <stddef.h> + * #include <ccan/build_assert/build_assert.h> + * + * struct foo { + * char string[5]; + * int x; + * }; + * + * static char *foo_string(struct foo *foo) + * { + * // This trick requires that the string be first in the structure + * BUILD_ASSERT(offsetof(struct foo, string) == 0); + * return (char *)foo; + * } + * + * License: CC0 (Public domain) + * Author: Rusty Russell <rusty@rustcorp.com.au> + */ +int main(int argc, char *argv[]) +{ + if (argc != 2) + return 1; + + if (strcmp(argv[1], "depends") == 0) + /* Nothing. */ + return 0; + + return 1; +} diff --git a/ccan/ccan/build_assert/build_assert.h b/ccan/ccan/build_assert/build_assert.h new file mode 100644 index 0000000..b9ecd84 --- /dev/null +++ b/ccan/ccan/build_assert/build_assert.h @@ -0,0 +1,40 @@ +/* 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 <stddef.h> + * ... + * 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 */ diff --git a/ccan/ccan/check_type/LICENSE b/ccan/ccan/check_type/LICENSE new file mode 120000 index 0000000..b7951da --- /dev/null +++ b/ccan/ccan/check_type/LICENSE @@ -0,0 +1 @@ +../../licenses/CC0
\ No newline at end of file diff --git a/ccan/ccan/check_type/_info b/ccan/ccan/check_type/_info new file mode 100644 index 0000000..cc42673 --- /dev/null +++ b/ccan/ccan/check_type/_info @@ -0,0 +1,33 @@ +#include "config.h" +#include <stdio.h> +#include <string.h> + +/** + * check_type - routines for compile time type checking + * + * C has fairly weak typing: ints get automatically converted to longs, signed + * to unsigned, etc. There are some cases where this is best avoided, and + * these macros provide methods for evoking warnings (or build errors) when + * a precise type isn't used. + * + * On compilers which don't support typeof() these routines are less effective, + * since they have to use sizeof() which can only distiguish between types of + * different size. + * + * License: CC0 (Public domain) + * Author: Rusty Russell <rusty@rustcorp.com.au> + */ +int main(int argc, char *argv[]) +{ + if (argc != 2) + return 1; + + if (strcmp(argv[1], "depends") == 0) { +#if !HAVE_TYPEOF + printf("ccan/build_assert\n"); +#endif + return 0; + } + + return 1; +} diff --git a/ccan/ccan/check_type/check_type.h b/ccan/ccan/check_type/check_type.h new file mode 100644 index 0000000..837aef7 --- /dev/null +++ b/ccan/ccan/check_type/check_type.h @@ -0,0 +1,64 @@ +/* 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(encl_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 <ccan/build_assert/build_assert.h> +/* 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 */ diff --git a/ccan/ccan/container_of/LICENSE b/ccan/ccan/container_of/LICENSE new file mode 120000 index 0000000..b7951da --- /dev/null +++ b/ccan/ccan/container_of/LICENSE @@ -0,0 +1 @@ +../../licenses/CC0
\ No newline at end of file diff --git a/ccan/ccan/container_of/_info b/ccan/ccan/container_of/_info new file mode 100644 index 0000000..b116052 --- /dev/null +++ b/ccan/ccan/container_of/_info @@ -0,0 +1,65 @@ +#include "config.h" +#include <stdio.h> +#include <string.h> + +/** + * container_of - routine for upcasting + * + * It is often convenient to create code where the caller registers a pointer + * to a generic structure and a callback. The callback might know that the + * pointer points to within a larger structure, and container_of gives a + * convenient and fairly type-safe way of returning to the enclosing structure. + * + * This idiom is an alternative to providing a void * pointer for every + * callback. + * + * Example: + * #include <stdio.h> + * #include <ccan/container_of/container_of.h> + * + * struct timer { + * void *members; + * }; + * + * struct info { + * int my_stuff; + * struct timer timer; + * }; + * + * static void my_timer_callback(struct timer *timer) + * { + * struct info *info = container_of(timer, struct info, timer); + * printf("my_stuff is %u\n", info->my_stuff); + * } + * + * static void register_timer(struct timer *timer) + * { + * (void)timer; + * (void)my_timer_callback; + * //... + * } + * + * int main(void) + * { + * struct info info = { .my_stuff = 1 }; + * + * register_timer(&info.timer); + * // ... + * return 0; + * } + * + * License: CC0 (Public domain) + * Author: Rusty Russell <rusty@rustcorp.com.au> + */ +int main(int argc, char *argv[]) +{ + if (argc != 2) + return 1; + + if (strcmp(argv[1], "depends") == 0) { + printf("ccan/check_type\n"); + return 0; + } + + return 1; +} diff --git a/ccan/ccan/container_of/container_of.h b/ccan/ccan/container_of/container_of.h new file mode 100644 index 0000000..47a34d8 --- /dev/null +++ b/ccan/ccan/container_of/container_of.h @@ -0,0 +1,145 @@ +/* CC0 (Public domain) - see LICENSE file for details */ +#ifndef CCAN_CONTAINER_OF_H +#define CCAN_CONTAINER_OF_H +#include <stddef.h> + +#include "config.h" +#include <ccan/check_type/check_type.h> + +/** + * 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_of_or_null - get pointer to enclosing structure, or NULL + * @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, unless it + * is given NULL, in which case it also returns NULL. + * + * Example: + * struct foo { + * int fielda, fieldb; + * // ... + * }; + * struct info { + * int some_other_field; + * struct foo my_foo; + * }; + * + * static struct info *foo_to_info_allowing_null(struct foo *foo) + * { + * return container_of_or_null(foo, struct info, my_foo); + * } + */ +static inline char *container_of_or_null_(void *member_ptr, size_t offset) +{ + return member_ptr ? (char *)member_ptr - offset : NULL; +} +#define container_of_or_null(member_ptr, containing_type, member) \ + ((containing_type *) \ + container_of_or_null_(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 */ diff --git a/ccan/ccan/endian/LICENSE b/ccan/ccan/endian/LICENSE new file mode 120000 index 0000000..b7951da --- /dev/null +++ b/ccan/ccan/endian/LICENSE @@ -0,0 +1 @@ +../../licenses/CC0
\ No newline at end of file diff --git a/ccan/ccan/endian/_info b/ccan/ccan/endian/_info new file mode 100644 index 0000000..efe5a8b --- /dev/null +++ b/ccan/ccan/endian/_info @@ -0,0 +1,55 @@ +#include "config.h" +#include <stdio.h> +#include <string.h> + +/** + * endian - endian conversion macros for simple types + * + * Portable protocols (such as on-disk formats, or network protocols) + * are often defined to be a particular endian: little-endian (least + * significant bytes first) or big-endian (most significant bytes + * first). + * + * Similarly, some CPUs lay out values in memory in little-endian + * order (most commonly, Intel's 8086 and derivatives), or big-endian + * order (almost everyone else). + * + * This module provides conversion routines, inspired by the linux kernel. + * It also provides leint32_t, beint32_t etc typedefs, which are annotated for + * the sparse checker. + * + * Example: + * #include <stdio.h> + * #include <err.h> + * #include <ccan/endian/endian.h> + * + * // + * int main(int argc, char *argv[]) + * { + * uint32_t value; + * + * if (argc != 2) + * errx(1, "Usage: %s <value>", argv[0]); + * + * value = atoi(argv[1]); + * printf("native: %08x\n", value); + * printf("little-endian: %08x\n", cpu_to_le32(value)); + * printf("big-endian: %08x\n", cpu_to_be32(value)); + * printf("byte-reversed: %08x\n", bswap_32(value)); + * exit(0); + * } + * + * License: License: CC0 (Public domain) + * Author: Rusty Russell <rusty@rustcorp.com.au> + */ +int main(int argc, char *argv[]) +{ + if (argc != 2) + return 1; + + if (strcmp(argv[1], "depends") == 0) + /* Nothing */ + return 0; + + return 1; +} diff --git a/ccan/ccan/endian/endian.h b/ccan/ccan/endian/endian.h new file mode 100644 index 0000000..3753f49 --- /dev/null +++ b/ccan/ccan/endian/endian.h @@ -0,0 +1,363 @@ +/* CC0 (Public domain) - see LICENSE file for details */ +#ifndef CCAN_ENDIAN_H +#define CCAN_ENDIAN_H +#include <stdint.h> +#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 <byteswap.h> +#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 + +/* Needed for Glibc like endiness check */ +#define __LITTLE_ENDIAN 1234 +#define __BIG_ENDIAN 4321 + +/* 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." +#elif HAVE_LITTLE_ENDIAN +#ifndef __BYTE_ORDER +#define __BYTE_ORDER __LITTLE_ENDIAN +#elif __BYTE_ORDER != __LITTLE_ENDIAN +#error "__BYTE_ORDER already defined, but not equal to __LITTLE_ENDIAN" +#endif +#elif HAVE_BIG_ENDIAN +#ifndef __BYTE_ORDER +#define __BYTE_ORDER __BIG_ENDIAN +#elif __BYTE_ORDER != __BIG_ENDIAN +#error "__BYTE_ORDER already defined, but not equal to __BIG_ENDIAN" +#endif +#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 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 */ diff --git a/ccan/ccan/list/LICENSE b/ccan/ccan/list/LICENSE new file mode 120000 index 0000000..2354d12 --- /dev/null +++ b/ccan/ccan/list/LICENSE @@ -0,0 +1 @@ +../../licenses/BSD-MIT
\ No newline at end of file diff --git a/ccan/ccan/list/_info b/ccan/ccan/list/_info new file mode 100644 index 0000000..c4f3e2a --- /dev/null +++ b/ccan/ccan/list/_info @@ -0,0 +1,72 @@ +#include "config.h" +#include <stdio.h> +#include <string.h> + +/** + * list - double linked list routines + * + * The list header contains routines for manipulating double linked lists. + * It defines two types: struct list_head used for anchoring lists, and + * struct list_node which is usually embedded in the structure which is placed + * in the list. + * + * Example: + * #include <err.h> + * #include <stdio.h> + * #include <stdlib.h> + * #include <ccan/list/list.h> + * + * struct parent { + * const char *name; + * struct list_head children; + * unsigned int num_children; + * }; + * + * struct child { + * const char *name; + * struct list_node list; + * }; + * + * int main(int argc, char *argv[]) + * { + * struct parent p; + * struct child *c; + * int i; + * + * if (argc < 2) + * errx(1, "Usage: %s parent children...", argv[0]); + * + * p.name = argv[1]; + * list_head_init(&p.children); + * p.num_children = 0; + * for (i = 2; i < argc; i++) { + * c = malloc(sizeof(*c)); + * c->name = argv[i]; + * list_add(&p.children, &c->list); + * p.num_children++; + * } + * + * printf("%s has %u children:", p.name, p.num_children); + * list_for_each(&p.children, c, list) + * printf("%s ", c->name); + * printf("\n"); + * return 0; + * } + * + * License: BSD-MIT + * Author: Rusty Russell <rusty@rustcorp.com.au> + */ +int main(int argc, char *argv[]) +{ + if (argc != 2) + return 1; + + if (strcmp(argv[1], "depends") == 0) { + printf("ccan/str\n"); + printf("ccan/container_of\n"); + printf("ccan/check_type\n"); + return 0; + } + + return 1; +} diff --git a/ccan/ccan/list/list.c b/ccan/ccan/list/list.c new file mode 100644 index 0000000..2717fa3 --- /dev/null +++ b/ccan/ccan/list/list.c @@ -0,0 +1,43 @@ +/* Licensed under BSD-MIT - see LICENSE file for details */ +#include <stdio.h> +#include <stdlib.h> +#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; +} diff --git a/ccan/ccan/list/list.h b/ccan/ccan/list/list.h new file mode 100644 index 0000000..a15321c --- /dev/null +++ b/ccan/ccan/list/list.h @@ -0,0 +1,842 @@ +/* Licensed under BSD-MIT - see LICENSE file for details */ +#ifndef CCAN_LIST_H +#define CCAN_LIST_H +//#define CCAN_LIST_DEBUG 1 +#include <stdbool.h> +#include <assert.h> +#include <ccan/str/str.h> +#include <ccan/container_of/container_of.h> +#include <ccan/check_type/check_type.h> + +/** + * 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) ((void)loc, h) +#define list_debug_node(n, loc) ((void)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_node_init - initialize a list_node + * @n: the list_node to link to itself. + * + * You don't need to use this normally! But it lets you list_del(@n) + * safely. + */ +static inline void list_node_init(struct list_node *n) +{ + n->next = n->prev = n; +} + +/** + * list_add_after - add an entry after an existing node in a linked list + * @h: the list_head to add the node to (for debugging) + * @p: the existing list_node to add the node after + * @n: the new list_node to add to the list. + * + * The existing list_node must already be a member of the list. + * The new list_node does not need to be initialized; it will be overwritten. + * + * Example: + * struct child c1, c2, c3; + * LIST_HEAD(h); + * + * list_add_tail(&h, &c1.list); + * list_add_tail(&h, &c3.list); + * list_add_after(&h, &c1.list, &c2.list); + */ +#define list_add_after(h, p, n) list_add_after_(h, p, n, LIST_LOC) +static inline void list_add_after_(struct list_head *h, + struct list_node *p, + struct list_node *n, + const char *abortstr) +{ + n->next = p->next; + n->prev = p; + p->next->prev = n; + p->next = n; + (void)list_debug(h, abortstr); +} + +/** + * 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) +{ + list_add_after_(h, &h->n, n, abortstr); +} + +/** + * list_add_before - add an entry before an existing node in a linked list + * @h: the list_head to add the node to (for debugging) + * @p: the existing list_node to add the node before + * @n: the new list_node to add to the list. + * + * The existing list_node must already be a member of the list. + * The new list_node does not need to be initialized; it will be overwritten. + * + * Example: + * list_head_init(&h); + * list_add_tail(&h, &c1.list); + * list_add_tail(&h, &c3.list); + * list_add_before(&h, &c3.list, &c2.list); + */ +#define list_add_before(h, p, n) list_add_before_(h, p, n, LIST_LOC) +static inline void list_add_before_(struct list_head *h, + struct list_node *p, + struct list_node *n, + const char *abortstr) +{ + n->next = p; + n->prev = p->prev; + p->prev->next = n; + p->prev = 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) +{ + list_add_before_(h, &h->n, n, 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_empty_nocheck - is a list empty? + * @h: the list_head + * + * If the list is empty, returns true. This doesn't perform any + * debug check for list consistency, so it can be called without + * locks, racing with the list being modified. This is ok for + * checks where an incorrect result is not an issue (optimized + * bail out path for example). + */ +static inline bool list_empty_nocheck(const struct list_head *h) +{ + return h->n.next == &h->n; +} + +/** + * 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(), list_del_init() + * + * 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_init - delete a node, and reset it so it can be deleted again. + * @n: the list_node to be deleted. + * + * list_del(@n) or list_del_init() again after this will be safe, + * which can be useful in some cases. + * + * See also: + * list_del_from(), list_del() + * + * Example: + * list_del_init(&child->list); + * parent->num_children--; + */ +#define list_del_init(n) list_del_init_(n, LIST_LOC) +static inline void list_del_init_(struct list_node *n, const char *abortstr) +{ + list_del_(n, abortstr); + list_node_init(n); +} + +/** + * 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_swap - swap out an entry from an (unknown) linked list for a new one. + * @o: the list_node to replace from the list. + * @n: the list_node to insert in place of the old one. + * + * Note that this leaves @o in an undefined state; it can be added to + * another list, but not deleted/swapped again. + * + * See also: + * list_del() + * + * Example: + * struct child x1, x2; + * LIST_HEAD(xh); + * + * list_add(&xh, &x1.list); + * list_swap(&x1.list, &x2.list); + */ +#define list_swap(o, n) list_swap_(o, n, LIST_LOC) +static inline void list_swap_(struct list_node *o, + struct list_node *n, + const char* abortstr) +{ + (void)list_debug_node(o, abortstr); + *n = *o; + n->next->prev = n; + n->prev->next = n; +#ifdef CCAN_LIST_DEBUG + /* Catch use-after-del. */ + o->next = o->prev = NULL; +#endif +} + +/** + * 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) \ + list_for_each_rev_off(h, i, list_off_var_(i, member)) + +/** + * list_for_each_rev_safe - iterate through a list backwards, + * 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 backwards. + * 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_rev_safe(&parent->children, child, next, list) { + * printf("Name: %s\n", child->name); + * } + */ +#define list_for_each_rev_safe(h, i, nxt, member) \ + list_for_each_rev_safe_off(h, i, nxt, list_off_var_(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: + * 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); +} + +/* internal macros, do not use directly */ +#define list_for_each_off_dir_(h, i, off, dir) \ + for (i = list_node_to_off_(list_debug(h, LIST_LOC)->n.dir, \ + (off)); \ + list_node_from_off_((void *)i, (off)) != &(h)->n; \ + i = list_node_to_off_(list_node_from_off_((void *)i, (off))->dir, \ + (off))) + +#define list_for_each_safe_off_dir_(h, i, nxt, off, dir) \ + for (i = list_node_to_off_(list_debug(h, LIST_LOC)->n.dir, \ + (off)), \ + nxt = list_node_to_off_(list_node_from_off_(i, (off))->dir, \ + (off)); \ + list_node_from_off_(i, (off)) != &(h)->n; \ + i = nxt, \ + nxt = list_node_to_off_(list_node_from_off_(i, (off))->dir, \ + (off))) + +/** + * list_for_each_off - iterate through a list of memory regions. + * @h: the list_head + * @i: the pointer to a memory region which 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 assumption made is that @i points + * to a chunk of memory that at some @offset, relative to @i, contains a + * properly filled `struct list_node' which in turn contains pointers to + * memory chunks and it's turtles all the way down. With all that in mind + * remember that given the wrong pointer/offset couple this macro will + * happily churn all you memory until 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) \ + list_for_each_off_dir_((h),(i),(off),next) + +/** + * list_for_each_rev_off - iterate through a list of memory regions backwards + * @h: the list_head + * @i: the pointer to a memory region which contains list node data. + * @off: offset(relative to @i) at which list node data resides. + * + * See list_for_each_off for details + */ +#define list_for_each_rev_off(h, i, off) \ + list_for_each_off_dir_((h),(i),(off),prev) + +/** + * 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 which 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) \ + list_for_each_safe_off_dir_((h),(i),(nxt),(off),next) + +/** + * list_for_each_rev_safe_off - iterate backwards through a list of + * memory regions, maybe during deletion + * @h: the list_head + * @i: the pointer to a memory region which 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_rev_off' and `list_for_each_rev_safe' + * descriptions. + * + * Example: + * list_for_each_rev_safe_off(&parent->children, child, + * next, offsetof(struct child, list)) + * printf("Name: %s\n", child->name); + */ +#define list_for_each_rev_safe_off(h, i, nxt, off) \ + list_for_each_safe_off_dir_((h),(i),(nxt),(off),prev) + +/* 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 */ diff --git a/ccan/ccan/minmax/LICENSE b/ccan/ccan/minmax/LICENSE new file mode 120000 index 0000000..b7951da --- /dev/null +++ b/ccan/ccan/minmax/LICENSE @@ -0,0 +1 @@ +../../licenses/CC0
\ No newline at end of file diff --git a/ccan/ccan/minmax/_info b/ccan/ccan/minmax/_info new file mode 100644 index 0000000..2f6437e --- /dev/null +++ b/ccan/ccan/minmax/_info @@ -0,0 +1,48 @@ +#include "config.h" +#include <stdio.h> +#include <string.h> + +/** + * minmax - typesafe minimum and maximum functions + * + * The classic implementation of minimum / maximum macros in C can be + * very dangerous. If the two arguments have different sizes, or + * different signedness, type promotion rules can lead to very + * surprising results. + * + * This module implements typesafe versions, which will generate a + * compile time error, if the arguments have different types. + * + * Example: + * #include <ccan/minmax/minmax.h> + * #include <stdio.h> + * + * int main(int argc, char *argv[]) + * { + * printf("Signed max: %d\n", max(1, -1)); + * printf("Unsigned max: %u\n", max(1U, -1U)); + * return 0; + * } + * + * Author: David Gibson <david@gibson.dropbear.id.au> + * License: CC0 (Public domain) + */ +int main(int argc, char *argv[]) +{ + /* Expect exactly one argument */ + if (argc != 2) + return 1; + + if (strcmp(argv[1], "depends") == 0) { + printf("ccan/build_assert\n"); + return 0; + } + + if (strcmp(argv[1], "ccanlint") == 0) { + /* We need several gcc extensions */ + printf("tests_compile_without_features FAIL\n"); + return 0; + } + + return 1; +} diff --git a/ccan/ccan/minmax/minmax.h b/ccan/ccan/minmax/minmax.h new file mode 100644 index 0000000..d111d1b --- /dev/null +++ b/ccan/ccan/minmax/minmax.h @@ -0,0 +1,65 @@ +/* CC0 (Public domain) - see LICENSE file for details */ +#ifndef CCAN_MINMAX_H +#define CCAN_MINMAX_H + +#include "config.h" + +#include <ccan/build_assert/build_assert.h> + +#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 */ diff --git a/ccan/ccan/short_types/LICENSE b/ccan/ccan/short_types/LICENSE new file mode 120000 index 0000000..b7951da --- /dev/null +++ b/ccan/ccan/short_types/LICENSE @@ -0,0 +1 @@ +../../licenses/CC0
\ No newline at end of file diff --git a/ccan/ccan/short_types/short_types.h b/ccan/ccan/short_types/short_types.h new file mode 100644 index 0000000..175377e --- /dev/null +++ b/ccan/ccan/short_types/short_types.h @@ -0,0 +1,35 @@ +/* CC0 (Public domain) - see LICENSE file for details */ +#ifndef CCAN_SHORT_TYPES_H +#define CCAN_SHORT_TYPES_H +#include <stdint.h> + +/** + * 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 */ diff --git a/ccan/ccan/str/LICENSE b/ccan/ccan/str/LICENSE new file mode 120000 index 0000000..b7951da --- /dev/null +++ b/ccan/ccan/str/LICENSE @@ -0,0 +1 @@ +../../licenses/CC0
\ No newline at end of file diff --git a/ccan/ccan/str/_info b/ccan/ccan/str/_info new file mode 100644 index 0000000..b579525 --- /dev/null +++ b/ccan/ccan/str/_info @@ -0,0 +1,52 @@ +#include "config.h" +#include <stdio.h> +#include <string.h> + +/** + * str - string helper routines + * + * This is a grab bag of functions for string operations, designed to enhance + * the standard string.h. + * + * Note that if you define CCAN_STR_DEBUG, you will get extra compile + * checks on common misuses of the following functions (they will now + * be out-of-line, so there is a runtime penalty!). + * + * strstr, strchr, strrchr: + * Return const char * if first argument is const (gcc only). + * + * isalnum, isalpha, isascii, isblank, iscntrl, isdigit, isgraph, + * islower, isprint, ispunct, isspace, isupper, isxdigit: + * Static and runtime check that input is EOF or an *unsigned* + * char, as per C standard (really!). + * + * Example: + * #include <stdio.h> + * #include <ccan/str/str.h> + * + * int main(int argc, char *argv[]) + * { + * if (argc > 1 && streq(argv[1], "--verbose")) + * printf("verbose set\n"); + * if (argc > 1 && strstarts(argv[1], "--")) + * printf("Some option set\n"); + * if (argc > 1 && strends(argv[1], "cow-powers")) + * printf("Magic option set\n"); + * return 0; + * } + * + * License: CC0 (Public domain) + * Author: Rusty Russell <rusty@rustcorp.com.au> + */ +int main(int argc, char *argv[]) +{ + if (argc != 2) + return 1; + + if (strcmp(argv[1], "depends") == 0) { + printf("ccan/build_assert\n"); + return 0; + } + + return 1; +} diff --git a/ccan/ccan/str/debug.c b/ccan/ccan/str/debug.c new file mode 100644 index 0000000..8c51944 --- /dev/null +++ b/ccan/ccan/str/debug.c @@ -0,0 +1,108 @@ +/* CC0 (Public domain) - see LICENSE file for details */ +#include "config.h" +#include <ccan/str/str_debug.h> +#include <assert.h> +#include <ctype.h> +#include <string.h> + +#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 diff --git a/ccan/ccan/str/str.c b/ccan/ccan/str/str.c new file mode 100644 index 0000000..a9245c1 --- /dev/null +++ b/ccan/ccan/str/str.c @@ -0,0 +1,13 @@ +/* CC0 (Public domain) - see LICENSE file for details */ +#include <ccan/str/str.h> + +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; +} diff --git a/ccan/ccan/str/str.h b/ccan/ccan/str/str.h new file mode 100644 index 0000000..d919b84 --- /dev/null +++ b/ccan/ccan/str/str.h @@ -0,0 +1,228 @@ +/* CC0 (Public domain) - see LICENSE file for details */ +#ifndef CCAN_STR_H +#define CCAN_STR_H +#include "config.h" +#include <string.h> +#include <stdbool.h> +#include <limits.h> +#include <ctype.h> + +/** + * 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) \ + (sizeof(({ typeof(type_or_expr) x = 0; 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 <ccan/str/str_debug.h> + +/* These checks force things out of line, hence they are under DEBUG. */ +#ifdef CCAN_STR_DEBUG +#include <ccan/build_assert/build_assert.h> + +/* 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 */ diff --git a/ccan/ccan/str/str_debug.h b/ccan/ccan/str/str_debug.h new file mode 100644 index 0000000..92c10c4 --- /dev/null +++ b/ccan/ccan/str/str_debug.h @@ -0,0 +1,30 @@ +/* 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 */ diff --git a/ccan/licenses/BSD-MIT b/ccan/licenses/BSD-MIT new file mode 100644 index 0000000..89de354 --- /dev/null +++ b/ccan/licenses/BSD-MIT @@ -0,0 +1,17 @@ +Permission 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. diff --git a/ccan/licenses/CC0 b/ccan/licenses/CC0 new file mode 100644 index 0000000..feb9b11 --- /dev/null +++ b/ccan/licenses/CC0 @@ -0,0 +1,28 @@ +Statement 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. diff --git a/ccan/meson.build b/ccan/meson.build new file mode 100644 index 0000000..a77240a --- /dev/null +++ b/ccan/meson.build @@ -0,0 +1,26 @@ +# SPDX-License-Identifier: LGPL-2.1-or-later +# +# This file is part of libnvme. +# Copyright (c) 2021 Dell Inc. +# +# Authors: Martin Belanger <Martin.Belanger@dell.com> +# + +sources = [ + 'ccan/list/list.c', + 'ccan/str/debug.c', + 'ccan/str/str.c', +] + +if get_option('buildtype') == 'debug' + add_project_arguments('-DCCAN_LIST_DEBUG=1', language : ['c', 'cpp']) + add_project_arguments('-DCCAN_STR_DEBUG=1', language : ['c', 'cpp']) +endif + +libccan = static_library( + 'ccan', + sources, + install: false, + include_directories: [incdir, internal_incdir], + dependencies: config_dep, +) diff --git a/doc/conf.py b/doc/conf.py new file mode 100644 index 0000000..422386a --- /dev/null +++ b/doc/conf.py @@ -0,0 +1,73 @@ +# Configuration file for the Sphinx documentation builder. +# +# This file only contains a selection of the most common options. For a full +# list see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +# -- Path setup -------------------------------------------------------------- + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. +# +# import os +# import sys +# sys.path.insert(0, os.path.abspath('.')) + + +# -- Project information ----------------------------------------------------- + +project = 'libnvme' +copyright = '2020, Keith Busch' +author = 'Keith Busch <kbusch@kernel.org>' +master_doc = 'libnvme' + +# The full version, including alpha/beta/rc tags +release = '0.1' + + +# -- General configuration --------------------------------------------------- + +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom +# ones. +extensions = [ +] + +# Add any paths that contain templates here, relative to this directory. +templates_path = ['_templates'] + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +# This pattern also affects html_static_path and html_extra_path. +exclude_patterns = ['html', 'man', 'index.rst', 'Thumbs.db', '.DS_Store'] + + +# -- Options for HTML output ------------------------------------------------- + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +# +#html_theme = 'alabaster' + +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named "default.css" will overwrite the builtin "default.css". +html_static_path = ['sphinx-static'] +html_context = { + 'css_files': [ + '_static/theme_overrides.css', + ], +} + +html_use_smartypants = False +pygments_style = 'sphinx' + +htmlhelp_basename = 'libnvme' + +try: + import sphinx_rtd_theme + html_theme = 'sphinx_rtd_theme' + html_theme_path = [sphinx_rtd_theme.get_html_theme_path()] +except ImportError: + sys.stderr.write('Warning: The Sphinx \'sphinx_rtd_theme\' HTML theme was not found. Make sure you have the theme installed to produce pretty HTML output. Falling back to the default theme.\n') diff --git a/doc/config-schema.json b/doc/config-schema.json new file mode 100644 index 0000000..a7bbdf1 --- /dev/null +++ b/doc/config-schema.json @@ -0,0 +1,164 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://github.com/linux-nvme/libnvme/doc/config-schema.json", + "title": "config.json", + "description": "libnvme JSON configuration", + "type": "object", + "properties": { + "hosts": { + "description": "Array of NVMe Host properties", + "type": "array", + "items": { "$ref": "#/$defs/host" } + } + }, + "$defs": { + "host": { + "description": "NVMe Host properties", + "type": "object", + "properties": { + "hostnqn": { + "description": "NVMe host NQN", + "type": "string", + "maxLength": 223 + }, + "hostid": { + "description": "NVMe host ID", + "type": "string" + }, + "hostsymname": { + "description": "NVMe host symbolic name", + "type": "string" + }, + "required": [ "hostnqn" ], + "subsystems": { + "description": "Array of NVMe subsystem properties", + "type": "array", + "items": { "$ref": "#/$defs/subsystem" } + } + } + }, + "subsystem": { + "description": "NVMe subsystem properties", + "type": "object", + "properties": { + "nqn": { + "description": "Subsystem NQN", + "type": "string", + "maxLength": 223 + }, + "ports": { + "description": "Array of NVMe subsystem ports", + "type": "array", + "items": { "$ref": "#/$defs/port" } + }, + "required": [ "nqn" ] + } + }, + "port": { + "description": "NVMe subsystem port", + "type": "object", + "properties": { + "transport": { + "description": "Transport type", + "type": "string" + }, + "traddr": { + "description": "Transport address", + "type": "string" + }, + "host_traddr": { + "description": "Host transport address", + "type": "string" + }, + "host_iface": { + "description": "Host interface name", + "type": "string" + }, + "trsvcid": { + "description": "Transport service identifier", + "type": "string" + }, + "dhchap_key": { + "description": "Host DH-HMAC-CHAP key", + "type": "string" + }, + "dhchap_ctrl_key": { + "description": "Controller DH-HMAC-CHAP key", + "type": "string" + }, + "nr_io_queues": { + "description": "Number of I/O queues", + "type": "integer" + }, + "nr_write_queues": { + "description": "Number of write queues", + "type": "integer" + }, + "nr_poll_queues": { + "description": "Number of poll queues", + "type": "integer" + }, + "queue_size": { + "description": "Queue size", + "type": "integer" + }, + "keep_alive_tmo": { + "description": "Keep-Alive timeout (in seconds)", + "type": "integer" + }, + "reconnect_delay": { + "description": "Reconnect delay (in seconds)", + "type": "integer" + }, + "ctrl_loss_tmo": { + "description": "Controller loss timeout (in seconds)", + "type": "integer" + }, + "fast_io_fail_tmo": { + "description": "Fast I/O Fail timeout (in seconds)", + "type": "integer", + "default": 600 + }, + "tos": { + "description": "Type of service", + "type": "integer", + "default": -1 + }, + "duplicate_connect": { + "description": "Allow duplicate connections", + "type": "boolean", + "default": false + }, + "disable_sqflow": { + "description": "Explicitly disable SQ flow control", + "type": "boolean", + "default": false + }, + "hdr_digest": { + "description": "Enable header digest", + "type": "boolean", + "default": false + }, + "data_digest": { + "description": "Enable data digest", + "type": "boolean", + "default": false + }, + "tls": { + "description": "Enable TLS encryption", + "type": "boolean", + "default": false + }, + "persistent": { + "description": "Create persistent discovery connection", + "type": "boolean" + }, + "discovery": { + "description": "Connect to a discovery controller", + "type": "boolean" + } + }, + "required": [ "transport" ] + } + } +} diff --git a/doc/index.rst b/doc/index.rst new file mode 100644 index 0000000..639b3d5 --- /dev/null +++ b/doc/index.rst @@ -0,0 +1,21 @@ +.. libnvme documentation master file, created by + sphinx-quickstart on Thu Feb 6 17:59:42 2020. + You can adapt this file completely to your liking, but it should at least + contain the root `toctree` directive. + +Welcome to libnvme's documentation! +=================================== + +.. toctree:: + :maxdepth: 2 + :caption: Contents: + + libnvme + + +Indices and tables +================== + +* :ref:`genindex` +* :ref:`modindex` +* :ref:`search` diff --git a/doc/kernel-doc b/doc/kernel-doc new file mode 100755 index 0000000..4900c3a --- /dev/null +++ b/doc/kernel-doc @@ -0,0 +1,2523 @@ +#!/usr/bin/env perl +# SPDX-License-Identifier: GPL-2.0 + +use warnings; +use strict; + +## Copyright (c) 1998 Michael Zucchi, All Rights Reserved ## +## Copyright (C) 2000, 1 Tim Waugh <twaugh@redhat.com> ## +## Copyright (C) 2001 Simon Huggins ## +## Copyright (C) 2005-2012 Randy Dunlap ## +## Copyright (C) 2012 Dan Luedtke ## +## ## +## #define enhancements by Armin Kuster <akuster@mvista.com> ## +## Copyright (c) 2000 MontaVista Software, Inc. ## +## ## +## This software falls under the GNU General Public License. ## +## Please read the COPYING file for more information ## + +# 18/01/2001 - Cleanups +# Functions prototyped as foo(void) same as foo() +# Stop eval'ing where we don't need to. +# -- huggie@earth.li + +# 27/06/2001 - Allowed whitespace after initial "/**" and +# allowed comments before function declarations. +# -- Christian Kreibich <ck@whoop.org> + +# Still to do: +# - add perldoc documentation +# - Look more closely at some of the scarier bits :) + +# 26/05/2001 - Support for separate source and object trees. +# Return error code. +# Keith Owens <kaos@ocs.com.au> + +# 23/09/2001 - Added support for typedefs, structs, enums and unions +# Support for Context section; can be terminated using empty line +# Small fixes (like spaces vs. \s in regex) +# -- Tim Jansen <tim@tjansen.de> + +# 25/07/2012 - Added support for HTML5 +# -- Dan Luedtke <mail@danrl.de> + +sub usage { + my $message = <<"EOF"; +Usage: $0 [OPTION ...] FILE ... + +Read C language source or header FILEs, extract embedded documentation comments, +and print formatted documentation to standard output. + +The documentation comments are identified by "/**" opening comment mark. See +Documentation/doc-guide/kernel-doc.rst for the documentation comment syntax. + +Output format selection (mutually exclusive): + -man Output troff manual page format. This is the default. + -rst Output reStructuredText format. + -none Do not output documentation, only warnings. + +Output format selection modifier (affects only ReST output): + + -sphinx-version Use the ReST C domain dialect compatible with an + specific Sphinx Version. + If not specified, kernel-doc will auto-detect using + the sphinx-build version found on PATH. + +Output selection (mutually exclusive): + -export Only output documentation for symbols that have been + exported using EXPORT_SYMBOL() or EXPORT_SYMBOL_GPL() + in any input FILE or -export-file FILE. + -internal Only output documentation for symbols that have NOT been + exported using EXPORT_SYMBOL() or EXPORT_SYMBOL_GPL() + in any input FILE or -export-file FILE. + -function NAME Only output documentation for the given function(s) + or DOC: section title(s). All other functions and DOC: + sections are ignored. May be specified multiple times. + -nosymbol NAME Exclude the specified symbols from the output + documentation. May be specified multiple times. + +Output selection modifiers: + -no-doc-sections Do not output DOC: sections. + -enable-lineno Enable output of #define LINENO lines. Only works with + reStructuredText format. + -export-file FILE Specify an additional FILE in which to look for + EXPORT_SYMBOL() and EXPORT_SYMBOL_GPL(). To be used with + -export or -internal. May be specified multiple times. + +Other parameters: + -v Verbose output, more warnings and other information. + -h Print this help. + -Werror Treat warnings as errors. + +EOF + print $message; + exit 1; +} + +# +# format of comments. +# In the following table, (...)? signifies optional structure. +# (...)* signifies 0 or more structure elements +# /** +# * function_name(:)? (- short description)? +# (* @parameterx: (description of parameter x)?)* +# (* a blank line)? +# * (Description:)? (Description of function)? +# * (section header: (section description)? )* +# (*)?*/ +# +# So .. the trivial example would be: +# +# /** +# * my_function +# */ +# +# If the Description: header tag is omitted, then there must be a blank line +# after the last parameter specification. +# e.g. +# /** +# * my_function - does my stuff +# * @my_arg: its mine damnit +# * +# * Does my stuff explained. +# */ +# +# or, could also use: +# /** +# * my_function - does my stuff +# * @my_arg: its mine damnit +# * Description: Does my stuff explained. +# */ +# etc. +# +# Besides functions you can also write documentation for structs, unions, +# enums and typedefs. Instead of the function name you must write the name +# of the declaration; the struct/union/enum/typedef must always precede +# the name. Nesting of declarations is not supported. +# Use the argument mechanism to document members or constants. +# e.g. +# /** +# * struct my_struct - short description +# * @a: first member +# * @b: second member +# * +# * Longer description +# */ +# struct my_struct { +# int a; +# int b; +# /* private: */ +# int c; +# }; +# +# All descriptions can be multiline, except the short function description. +# +# For really longs structs, you can also describe arguments inside the +# body of the struct. +# eg. +# /** +# * struct my_struct - short description +# * @a: first member +# * @b: second member +# * +# * Longer description +# */ +# struct my_struct { +# int a; +# int b; +# /** +# * @c: This is longer description of C +# * +# * You can use paragraphs to describe arguments +# * using this method. +# */ +# int c; +# }; +# +# This should be use only for struct/enum members. +# +# You can also add additional sections. When documenting kernel functions you +# should document the "Context:" of the function, e.g. whether the functions +# can be called form interrupts. Unlike other sections you can end it with an +# empty line. +# A non-void function should have a "Return:" section describing the return +# value(s). +# Example-sections should contain the string EXAMPLE so that they are marked +# appropriately in DocBook. +# +# Example: +# /** +# * user_function - function that can only be called in user context +# * @a: some argument +# * Context: !in_interrupt() +# * +# * Some description +# * Example: +# * user_function(22); +# */ +# ... +# +# +# All descriptive text is further processed, scanning for the following special +# patterns, which are highlighted appropriately. +# +# 'funcname()' - function +# '$ENVVAR' - environmental variable +# '&struct_name' - name of a structure (up to two words including 'struct') +# '&struct_name.member' - name of a structure member +# '@parameter' - name of a parameter +# '%CONST' - name of a constant. +# '``LITERAL``' - literal string without any spaces on it. + +## init lots of data + +my $errors = 0; +my $warnings = 0; +my $anon_struct_union = 0; + +# match expressions used to find embedded type information +my $type_constant = '\b``([^\`]+)``\b'; +my $type_constant2 = '\%([-_\w]+)'; +my $type_func = '(\w+)\(\)'; +my $type_param = '\@(\w*((\.\w+)|(->\w+))*(\.\.\.)?)'; +my $type_param_ref = '([\!]?)\@(\w*((\.\w+)|(->\w+))*(\.\.\.)?)'; +my $type_fp_param = '\@(\w+)\(\)'; # Special RST handling for func ptr params +my $type_fp_param2 = '\@(\w+->\S+)\(\)'; # Special RST handling for structs with func ptr params +my $type_env = '(\$\w+)'; +my $type_enum = '\&(enum\s*([_\w]+))'; +my $type_struct = '\&(struct\s*([_\w]+))'; +my $type_typedef = '\&(typedef\s*([_\w]+))'; +my $type_union = '\&(union\s*([_\w]+))'; +my $type_member = '\&([_\w]+)(\.|->)([_\w]+)'; +my $type_fallback = '\&([_\w]+)'; +my $type_member_func = $type_member . '\(\)'; + +# Output conversion substitutions. +# One for each output format + +# these are pretty rough +my @highlights_man = ( + [$type_constant, "\$1"], + [$type_constant2, "\$1"], + [$type_func, "\\\\fB\$1\\\\fP"], + [$type_enum, "\\\\fI\$1\\\\fP"], + [$type_struct, "\\\\fI\$1\\\\fP"], + [$type_typedef, "\\\\fI\$1\\\\fP"], + [$type_union, "\\\\fI\$1\\\\fP"], + [$type_param, "\\\\fI\$1\\\\fP"], + [$type_param_ref, "\\\\fI\$1\$2\\\\fP"], + [$type_member, "\\\\fI\$1\$2\$3\\\\fP"], + [$type_fallback, "\\\\fI\$1\\\\fP"] + ); +my $blankline_man = ""; + +# rst-mode +my @highlights_rst = ( + [$type_constant, "``\$1``"], + [$type_constant2, "``\$1``"], + # Note: need to escape () to avoid func matching later + [$type_member_func, "\\:c\\:type\\:`\$1\$2\$3\\\\(\\\\) <\$1>`"], + [$type_member, "\\:c\\:type\\:`\$1\$2\$3 <\$1>`"], + [$type_fp_param, "**\$1\\\\(\\\\)**"], + [$type_fp_param2, "**\$1\\\\(\\\\)**"], + [$type_func, "\$1()"], + [$type_enum, "\\:c\\:type\\:`\$1 <\$2>`"], + [$type_struct, "\\:c\\:type\\:`\$1 <\$2>`"], + [$type_typedef, "\\:c\\:type\\:`\$1 <\$2>`"], + [$type_union, "\\:c\\:type\\:`\$1 <\$2>`"], + # in rst this can refer to any type + [$type_fallback, "\\:c\\:type\\:`\$1`"], + [$type_param_ref, "**\$1\$2**"] + ); +my $blankline_rst = "\n"; + +# read arguments +if ($#ARGV == -1) { + usage(); +} + +my $kernelversion; +my ($sphinx_major, $sphinx_minor, $sphinx_patch); + +my $dohighlight = ""; + +my $verbose = 0; +my $Werror = 0; +my $output_mode = "rst"; +my $output_preformatted = 0; +my $no_doc_sections = 0; +my $enable_lineno = 0; +my @highlights = @highlights_rst; +my $blankline = $blankline_rst; +my $modulename = "Kernel API"; + +use constant { + OUTPUT_ALL => 0, # output all symbols and doc sections + OUTPUT_INCLUDE => 1, # output only specified symbols + OUTPUT_EXPORTED => 2, # output exported symbols + OUTPUT_INTERNAL => 3, # output non-exported symbols +}; +my $output_selection = OUTPUT_ALL; +my $show_not_found = 0; # No longer used + +my @export_file_list; + +my @build_time; +if (defined($ENV{'KBUILD_BUILD_TIMESTAMP'}) && + (my $seconds = `date -d"${ENV{'KBUILD_BUILD_TIMESTAMP'}}" +%s`) ne '') { + @build_time = gmtime($seconds); +} else { + @build_time = localtime; +} + +my $man_date = ('January', 'February', 'March', 'April', 'May', 'June', + 'July', 'August', 'September', 'October', + 'November', 'December')[$build_time[4]] . + " " . ($build_time[5]+1900); + +# Essentially these are globals. +# They probably want to be tidied up, made more localised or something. +# CAVEAT EMPTOR! Some of the others I localised may not want to be, which +# could cause "use of undefined value" or other bugs. +my ($function, %function_table, %parametertypes, $declaration_purpose); +my %nosymbol_table = (); +my $declaration_start_line; +my ($type, $declaration_name, $return_type); +my ($newsection, $newcontents, $prototype, $brcount, %source_map); + +if (defined($ENV{'KBUILD_VERBOSE'})) { + $verbose = "$ENV{'KBUILD_VERBOSE'}"; +} + +if (defined($ENV{'KCFLAGS'})) { + my $kcflags = "$ENV{'KCFLAGS'}"; + + if ($kcflags =~ /Werror/) { + $Werror = 1; + } +} + +if (defined($ENV{'KDOC_WERROR'})) { + $Werror = "$ENV{'KDOC_WERROR'}"; +} + +# Generated docbook code is inserted in a template at a point where +# docbook v3.1 requires a non-zero sequence of RefEntry's; see: +# https://www.oasis-open.org/docbook/documentation/reference/html/refentry.html +# We keep track of number of generated entries and generate a dummy +# if needs be to ensure the expanded template can be postprocessed +# into html. +my $section_counter = 0; + +my $lineprefix=""; + +# Parser states +use constant { + STATE_NORMAL => 0, # normal code + STATE_NAME => 1, # looking for function name + STATE_BODY_MAYBE => 2, # body - or maybe more description + STATE_BODY => 3, # the body of the comment + STATE_BODY_WITH_BLANK_LINE => 4, # the body, which has a blank line + STATE_PROTO => 5, # scanning prototype + STATE_DOCBLOCK => 6, # documentation block + STATE_INLINE => 7, # gathering doc outside main block +}; +my $state; +my $in_doc_sect; +my $leading_space; + +# Inline documentation state +use constant { + STATE_INLINE_NA => 0, # not applicable ($state != STATE_INLINE) + STATE_INLINE_NAME => 1, # looking for member name (@foo:) + STATE_INLINE_TEXT => 2, # looking for member documentation + STATE_INLINE_END => 3, # done + STATE_INLINE_ERROR => 4, # error - Comment without header was found. + # Spit a warning as it's not + # proper kernel-doc and ignore the rest. +}; +my $inline_doc_state; + +#declaration types: can be +# 'function', 'struct', 'union', 'enum', 'typedef' +my $decl_type; + +# Name of the kernel-doc identifier for non-DOC markups +my $identifier; + +my $doc_start = '^/\*\*\s*$'; # Allow whitespace at end of comment start. +my $doc_end = '\*/'; +my $doc_com = '\s*\*\s*'; +my $doc_com_body = '\s*\* ?'; +my $doc_decl = $doc_com . '(\w+)'; +# @params and a strictly limited set of supported section names +# Specifically: +# Match @word: +# @...: +# @{section-name}: +# while trying to not match literal block starts like "example::" +# +my $doc_sect = $doc_com . + '\s*(\@[.\w]+|\@\.\.\.|description|context|returns?|notes?|examples?)\s*:([^:].*)?$'; +my $doc_content = $doc_com_body . '(.*)'; +my $doc_block = $doc_com . 'DOC:\s*(.*)?'; +my $doc_inline_start = '^\s*/\*\*\s*$'; +my $doc_inline_sect = '\s*\*\s*(@\s*[\w][\w\.]*\s*):(.*)'; +my $doc_inline_end = '^\s*\*/\s*$'; +my $doc_inline_oneline = '^\s*/\*\*\s*(@[\w\s]+):\s*(.*)\s*\*/\s*$'; +my $export_symbol = '^\s*EXPORT_SYMBOL(_GPL)?\s*\(\s*(\w+)\s*\)\s*;'; +my $function_pointer = qr{([^\(]*\(\*)\s*\)\s*\(([^\)]*)\)}; +my $attribute = qr{__attribute__\s*\(\([a-z0-9,_\*\s\(\)]*\)\)}i; + +my %parameterdescs; +my %parameterdesc_start_lines; +my @parameterlist; +my %sections; +my @sectionlist; +my %section_start_lines; +my $sectcheck; +my $struct_actual; + +my $contents = ""; +my $new_start_line = 0; + +# the canonical section names. see also $doc_sect above. +my $section_default = "Description"; # default section +my $section_intro = "Introduction"; +my $section = $section_default; +my $section_context = "Context"; +my $section_return = "Return"; + +my $undescribed = "-- undescribed --"; + +reset_state(); + +while ($ARGV[0] =~ m/^--?(.*)/) { + my $cmd = $1; + shift @ARGV; + if ($cmd eq "man") { + $output_mode = "man"; + @highlights = @highlights_man; + $blankline = $blankline_man; + } elsif ($cmd eq "rst") { + $output_mode = "rst"; + @highlights = @highlights_rst; + $blankline = $blankline_rst; + } elsif ($cmd eq "none") { + $output_mode = "none"; + } elsif ($cmd eq "module") { # not needed for XML, inherits from calling document + $modulename = shift @ARGV; + } elsif ($cmd eq "function") { # to only output specific functions + $output_selection = OUTPUT_INCLUDE; + $function = shift @ARGV; + $function_table{$function} = 1; + } elsif ($cmd eq "nosymbol") { # Exclude specific symbols + my $symbol = shift @ARGV; + $nosymbol_table{$symbol} = 1; + } elsif ($cmd eq "export") { # only exported symbols + $output_selection = OUTPUT_EXPORTED; + %function_table = (); + } elsif ($cmd eq "internal") { # only non-exported symbols + $output_selection = OUTPUT_INTERNAL; + %function_table = (); + } elsif ($cmd eq "export-file") { + my $file = shift @ARGV; + push(@export_file_list, $file); + } elsif ($cmd eq "v") { + $verbose = 1; + } elsif ($cmd eq "Werror") { + $Werror = 1; + } elsif (($cmd eq "h") || ($cmd eq "help")) { + usage(); + } elsif ($cmd eq 'no-doc-sections') { + $no_doc_sections = 1; + } elsif ($cmd eq 'enable-lineno') { + $enable_lineno = 1; + } elsif ($cmd eq 'show-not-found') { + $show_not_found = 1; # A no-op but don't fail + } elsif ($cmd eq "sphinx-version") { + my $ver_string = shift @ARGV; + if ($ver_string =~ m/^(\d+)(\.\d+)?(\.\d+)?/) { + $sphinx_major = $1; + if (defined($2)) { + $sphinx_minor = substr($2,1); + } else { + $sphinx_minor = 0; + } + if (defined($3)) { + $sphinx_patch = substr($3,1) + } else { + $sphinx_patch = 0; + } + } else { + die "Sphinx version should either major.minor or major.minor.patch format\n"; + } + } else { + # Unknown argument + usage(); + } +} + +# continue execution near EOF; + +# The C domain dialect changed on Sphinx 3. So, we need to check the +# version in order to produce the right tags. +sub findprog($) +{ + foreach(split(/:/, $ENV{PATH})) { + return "$_/$_[0]" if(-x "$_/$_[0]"); + } +} + +sub get_sphinx_version() +{ + my $ver; + + my $cmd = "sphinx-build"; + if (!findprog($cmd)) { + my $cmd = "sphinx-build3"; + if (!findprog($cmd)) { + $sphinx_major = 1; + $sphinx_minor = 2; + $sphinx_patch = 0; + printf STDERR "Warning: Sphinx version not found. Using default (Sphinx version %d.%d.%d)\n", + $sphinx_major, $sphinx_minor, $sphinx_patch; + return; + } + } + + open IN, "$cmd --version 2>&1 |"; + while (<IN>) { + if (m/^\s*sphinx-build\s+([\d]+)\.([\d\.]+)(\+\/[\da-f]+)?$/) { + $sphinx_major = $1; + $sphinx_minor = $2; + $sphinx_patch = $3; + last; + } + # Sphinx 1.2.x uses a different format + if (m/^\s*Sphinx.*\s+([\d]+)\.([\d\.]+)$/) { + $sphinx_major = $1; + $sphinx_minor = $2; + $sphinx_patch = $3; + last; + } + } + close IN; +} + +# get kernel version from env +sub get_kernel_version() { + my $version = 'unknown kernel version'; + + if (defined($ENV{'KERNELVERSION'})) { + $version = $ENV{'KERNELVERSION'}; + } + return $version; +} + +# +sub print_lineno { + my $lineno = shift; + if ($enable_lineno && defined($lineno)) { + print "#define LINENO " . $lineno . "\n"; + } +} +## +# dumps section contents to arrays/hashes intended for that purpose. +# +sub dump_section { + my $file = shift; + my $name = shift; + my $contents = join "\n", @_; + + if ($name =~ m/$type_param/) { + $name = $1; + $parameterdescs{$name} = $contents; + $sectcheck = $sectcheck . $name . " "; + $parameterdesc_start_lines{$name} = $new_start_line; + $new_start_line = 0; + } elsif ($name eq "@\.\.\.") { + $name = "..."; + $parameterdescs{$name} = $contents; + $sectcheck = $sectcheck . $name . " "; + $parameterdesc_start_lines{$name} = $new_start_line; + $new_start_line = 0; + } else { + if (defined($sections{$name}) && ($sections{$name} ne "")) { + # Only warn on user specified duplicate section names. + if ($name ne $section_default) { + print STDERR "${file}:$.: warning: duplicate section name '$name'\n"; + ++$warnings; + } + $sections{$name} .= $contents; + } else { + $sections{$name} = $contents; + push @sectionlist, $name; + $section_start_lines{$name} = $new_start_line; + $new_start_line = 0; + } + } +} + +## +# dump DOC: section after checking that it should go out +# +sub dump_doc_section { + my $file = shift; + my $name = shift; + my $contents = join "\n", @_; + + if ($no_doc_sections) { + return; + } + + return if (defined($nosymbol_table{$name})); + + if (($output_selection == OUTPUT_ALL) || + (($output_selection == OUTPUT_INCLUDE) && + defined($function_table{$name}))) + { + dump_section($file, $name, $contents); + output_blockhead({'sectionlist' => \@sectionlist, + 'sections' => \%sections, + 'module' => $modulename, + 'content-only' => ($output_selection != OUTPUT_ALL), }); + } +} + +## +# output function +# +# parameterdescs, a hash. +# function => "function name" +# parameterlist => @list of parameters +# parameterdescs => %parameter descriptions +# sectionlist => @list of sections +# sections => %section descriptions +# + +sub output_highlight { + my $contents = join "\n",@_; + my $line; + +# DEBUG +# if (!defined $contents) { +# use Carp; +# confess "output_highlight got called with no args?\n"; +# } + +# print STDERR "contents b4:$contents\n"; + eval $dohighlight; + die $@ if $@; +# print STDERR "contents af:$contents\n"; + + foreach $line (split "\n", $contents) { + if (! $output_preformatted) { + $line =~ s/^\s*//; + } + if ($line eq ""){ + if (! $output_preformatted) { + print $lineprefix, $blankline; + } + } else { + if ($output_mode eq "man" && substr($line, 0, 1) eq ".") { + print "\\&$line"; + } else { + print $lineprefix, $line; + } + } + print "\n"; + } +} + +## +# output function in man +sub output_function_man(%) { + my %args = %{$_[0]}; + my ($parameter, $section); + my $count; + + print ".TH \"$args{'function'}\" 9 \"$args{'function'}\" \"$man_date\" \"libnvme API manual\" LINUX\n"; + + print ".SH NAME\n"; + print $args{'function'} . " \\- " . $args{'purpose'} . "\n"; + + print ".SH SYNOPSIS\n"; + if ($args{'functiontype'} ne "") { + print ".B \"" . $args{'functiontype'} . "\" " . $args{'function'} . "\n"; + } else { + print ".B \"" . $args{'function'} . "\n"; + } + $count = 0; + my $parenth = "("; + my $post = ","; + foreach my $parameter (@{$args{'parameterlist'}}) { + if ($count == $#{$args{'parameterlist'}}) { + $post = ");"; + } + $type = $args{'parametertypes'}{$parameter}; + if ($type =~ m/$function_pointer/) { + # pointer-to-function + print ".BI \"" . $parenth . $1 . "\" " . " \") (" . $2 . ")" . $post . "\"\n"; + } else { + $type =~ s/([^\*])$/$1 /; + print ".BI \"" . $parenth . $type . "\" " . " \"" . $post . "\"\n"; + } + $count++; + $parenth = ""; + } + + print ".SH ARGUMENTS\n"; + foreach $parameter (@{$args{'parameterlist'}}) { + my $parameter_name = $parameter; + $parameter_name =~ s/\[.*//; + + print ".IP \"" . $parameter . "\" 12\n"; + output_highlight($args{'parameterdescs'}{$parameter_name}); + } + foreach $section (@{$args{'sectionlist'}}) { + print ".SH \"", uc $section, "\"\n"; + output_highlight($args{'sections'}{$section}); + } +} + +## +# output enum in man +sub output_enum_man(%) { + my %args = %{$_[0]}; + my ($parameter, $section); + my $count; + + print ".TH \"$args{'module'}\" 9 \"enum $args{'enum'}\" \"$man_date\" \"API Manual\" LINUX\n"; + + print ".SH NAME\n"; + print "enum " . $args{'enum'} . " \\- " . $args{'purpose'} . "\n"; + + print ".SH SYNOPSIS\n"; + print "enum " . $args{'enum'} . " {\n"; + $count = 0; + foreach my $parameter (@{$args{'parameterlist'}}) { + print ".br\n.BI \" $parameter\"\n"; + if ($count == $#{$args{'parameterlist'}}) { + print "\n};\n"; + last; + } + else { + print ", \n.br\n"; + } + $count++; + } + + print ".SH Constants\n"; + foreach $parameter (@{$args{'parameterlist'}}) { + my $parameter_name = $parameter; + $parameter_name =~ s/\[.*//; + + print ".IP \"" . $parameter . "\" 12\n"; + output_highlight($args{'parameterdescs'}{$parameter_name}); + } + foreach $section (@{$args{'sectionlist'}}) { + print ".SH \"$section\"\n"; + output_highlight($args{'sections'}{$section}); + } +} + +## +# output struct in man +sub output_struct_man(%) { + my %args = %{$_[0]}; + my ($parameter, $section); + + print ".TH \"$args{'module'}\" 9 \"" . $args{'type'} . " " . $args{'struct'} . "\" \"$man_date\" \"API Manual\" LINUX\n"; + + print ".SH NAME\n"; + print $args{'type'} . " " . $args{'struct'} . " \\- " . $args{'purpose'} . "\n"; + + my $declaration = $args{'definition'}; + $declaration =~ s/\t/ /g; + $declaration =~ s/\n/"\n.br\n.BI \"/g; + print ".SH SYNOPSIS\n"; + print $args{'type'} . " " . $args{'struct'} . " {\n.br\n"; + print ".BI \"$declaration\n};\n.br\n\n"; + + print ".SH Members\n"; + foreach $parameter (@{$args{'parameterlist'}}) { + ($parameter =~ /^#/) && next; + + my $parameter_name = $parameter; + $parameter_name =~ s/\[.*//; + + ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next; + print ".IP \"" . $parameter . "\" 12\n"; + output_highlight($args{'parameterdescs'}{$parameter_name}); + } + foreach $section (@{$args{'sectionlist'}}) { + print ".SH \"$section\"\n"; + output_highlight($args{'sections'}{$section}); + } +} + +## +# output typedef in man +sub output_typedef_man(%) { + my %args = %{$_[0]}; + my ($parameter, $section); + + print ".TH \"$args{'module'}\" 9 \"$args{'typedef'}\" \"$man_date\" \"API Manual\" LINUX\n"; + + print ".SH NAME\n"; + print "typedef " . $args{'typedef'} . " \\- " . $args{'purpose'} . "\n"; + + foreach $section (@{$args{'sectionlist'}}) { + print ".SH \"$section\"\n"; + output_highlight($args{'sections'}{$section}); + } +} + +sub output_blockhead_man(%) { + my %args = %{$_[0]}; + my ($parameter, $section); + my $count; + + print ".TH \"$args{'module'}\" 9 \"$args{'module'}\" \"$man_date\" \"API Manual\" LINUX\n"; + + foreach $section (@{$args{'sectionlist'}}) { + print ".SH \"$section\"\n"; + output_highlight($args{'sections'}{$section}); + } +} + +## +# output in restructured text +# + +# +# This could use some work; it's used to output the DOC: sections, and +# starts by putting out the name of the doc section itself, but that tends +# to duplicate a header already in the template file. +# +sub output_blockhead_rst(%) { + my %args = %{$_[0]}; + my ($parameter, $section); + + foreach $section (@{$args{'sectionlist'}}) { + next if (defined($nosymbol_table{$section})); + + if ($output_selection != OUTPUT_INCLUDE) { + print ".. _$section:\n\n"; + print "**$section**\n\n"; + } + print_lineno($section_start_lines{$section}); + output_highlight_rst($args{'sections'}{$section}); + print "\n"; + } +} + +# +# Apply the RST highlights to a sub-block of text. +# +sub highlight_block($) { + # The dohighlight kludge requires the text be called $contents + my $contents = shift; + eval $dohighlight; + die $@ if $@; + return $contents; +} + +# +# Regexes used only here. +# +my $sphinx_literal = '^[^.].*::$'; +my $sphinx_cblock = '^\.\.\ +code-block::'; + +sub output_highlight_rst { + my $input = join "\n",@_; + my $output = ""; + my $line; + my $in_literal = 0; + my $litprefix; + my $block = ""; + + foreach $line (split "\n",$input) { + # + # If we're in a literal block, see if we should drop out + # of it. Otherwise pass the line straight through unmunged. + # + if ($in_literal) { + if (! ($line =~ /^\s*$/)) { + # + # If this is the first non-blank line in a literal + # block we need to figure out what the proper indent is. + # + if ($litprefix eq "") { + $line =~ /^(\s*)/; + $litprefix = '^' . $1; + $output .= $line . "\n"; + } elsif (! ($line =~ /$litprefix/)) { + $in_literal = 0; + } else { + $output .= $line . "\n"; + } + } else { + $output .= $line . "\n"; + } + } + # + # Not in a literal block (or just dropped out) + # + if (! $in_literal) { + $block .= $line . "\n"; + if (($line =~ /$sphinx_literal/) || ($line =~ /$sphinx_cblock/)) { + $in_literal = 1; + $litprefix = ""; + $output .= highlight_block($block); + $block = "" + } + } + } + + if ($block) { + $output .= highlight_block($block); + } + foreach $line (split "\n", $output) { + print $lineprefix . $line . "\n"; + } +} + +sub output_function_rst(%) { + my %args = %{$_[0]}; + my ($parameter, $section); + my $oldprefix = $lineprefix; + my $start = ""; + my $is_macro = 0; + + if ($sphinx_major < 3) { + if ($args{'typedef'}) { + print ".. c:type:: ". $args{'function'} . "\n\n"; + print_lineno($declaration_start_line); + print " **Typedef**: "; + $lineprefix = ""; + output_highlight_rst($args{'purpose'}); + $start = "\n\n**Syntax**\n\n ``"; + $is_macro = 1; + } else { + print ".. c:function:: "; + } + } else { + if ($args{'typedef'} || $args{'functiontype'} eq "") { + $is_macro = 1; + print ".. c:macro:: ". $args{'function'} . "\n\n"; + } else { + print ".. c:function:: "; + } + + if ($args{'typedef'}) { + print_lineno($declaration_start_line); + print " **Typedef**: "; + $lineprefix = ""; + output_highlight_rst($args{'purpose'}); + $start = "\n\n**Syntax**\n\n ``"; + } else { + print "``" if ($is_macro); + } + } + if ($args{'functiontype'} ne "") { + $start .= $args{'functiontype'} . " " . $args{'function'} . " ("; + } else { + $start .= $args{'function'} . " ("; + } + print $start; + + my $count = 0; + foreach my $parameter (@{$args{'parameterlist'}}) { + if ($count ne 0) { + print ", "; + } + $count++; + $type = $args{'parametertypes'}{$parameter}; + + if ($type =~ m/$function_pointer/) { + # pointer-to-function + print $1 . $parameter . ") (" . $2 . ")"; + } else { + print $type; + } + } + if ($is_macro) { + print ")``\n\n"; + } else { + print ")\n\n"; + } + if (!$args{'typedef'}) { + print_lineno($declaration_start_line); + $lineprefix = " "; + output_highlight_rst($args{'purpose'}); + print "\n"; + } + + print "**Parameters**\n\n"; + $lineprefix = " "; + foreach $parameter (@{$args{'parameterlist'}}) { + my $parameter_name = $parameter; + $parameter_name =~ s/\[.*//; + $type = $args{'parametertypes'}{$parameter}; + + if ($type ne "") { + print "``$type``\n"; + } else { + print "``$parameter``\n"; + } + + print_lineno($parameterdesc_start_lines{$parameter_name}); + + if (defined($args{'parameterdescs'}{$parameter_name}) && + $args{'parameterdescs'}{$parameter_name} ne $undescribed) { + output_highlight_rst($args{'parameterdescs'}{$parameter_name}); + } else { + print " *undescribed*\n"; + } + print "\n"; + } + + $lineprefix = $oldprefix; + output_section_rst(@_); +} + +sub output_section_rst(%) { + my %args = %{$_[0]}; + my $section; + my $oldprefix = $lineprefix; + $lineprefix = ""; + + foreach $section (@{$args{'sectionlist'}}) { + print "**$section**\n\n"; + print_lineno($section_start_lines{$section}); + output_highlight_rst($args{'sections'}{$section}); + print "\n"; + } + print "\n"; + $lineprefix = $oldprefix; +} + +sub output_enum_rst(%) { + my %args = %{$_[0]}; + my ($parameter); + my $oldprefix = $lineprefix; + my $count; + + if ($sphinx_major < 3) { + my $name = "enum " . $args{'enum'}; + print "\n\n.. c:type:: " . $name . "\n\n"; + } else { + my $name = $args{'enum'}; + print "\n\n.. c:enum:: " . $name . "\n\n"; + } + print_lineno($declaration_start_line); + $lineprefix = " "; + output_highlight_rst($args{'purpose'}); + print "\n"; + + print "**Constants**\n\n"; + $lineprefix = " "; + foreach $parameter (@{$args{'parameterlist'}}) { + print "``$parameter``\n"; + if ($args{'parameterdescs'}{$parameter} ne $undescribed) { + output_highlight_rst($args{'parameterdescs'}{$parameter}); + } else { + print " *undescribed*\n"; + } + print "\n"; + } + + $lineprefix = $oldprefix; + output_section_rst(@_); +} + +sub output_typedef_rst(%) { + my %args = %{$_[0]}; + my ($parameter); + my $oldprefix = $lineprefix; + my $name; + + if ($sphinx_major < 3) { + $name = "typedef " . $args{'typedef'}; + } else { + $name = $args{'typedef'}; + } + print "\n\n.. c:type:: " . $name . "\n\n"; + print_lineno($declaration_start_line); + $lineprefix = " "; + output_highlight_rst($args{'purpose'}); + print "\n"; + + $lineprefix = $oldprefix; + output_section_rst(@_); +} + +sub output_struct_rst(%) { + my %args = %{$_[0]}; + my ($parameter); + my $oldprefix = $lineprefix; + + if ($sphinx_major < 3) { + my $name = $args{'type'} . " " . $args{'struct'}; + print "\n\n.. c:type:: " . $name . "\n\n"; + } else { + my $name = $args{'struct'}; + if ($args{'type'} eq 'union') { + print "\n\n.. c:union:: " . $name . "\n\n"; + } else { + print "\n\n.. c:struct:: " . $name . "\n\n"; + } + } + print_lineno($declaration_start_line); + $lineprefix = " "; + output_highlight_rst($args{'purpose'}); + print "\n"; + + print "**Definition**\n\n"; + print "::\n\n"; + my $declaration = $args{'definition'}; + $declaration =~ s/\t/ /g; + print " " . $args{'type'} . " " . $args{'struct'} . " {\n$declaration };\n\n"; + + print "**Members**\n\n"; + $lineprefix = " "; + foreach $parameter (@{$args{'parameterlist'}}) { + ($parameter =~ /^#/) && next; + + my $parameter_name = $parameter; + $parameter_name =~ s/\[.*//; + + ($args{'parameterdescs'}{$parameter_name} ne $undescribed) || next; + $type = $args{'parametertypes'}{$parameter}; + print_lineno($parameterdesc_start_lines{$parameter_name}); + print "``" . $parameter . "``\n"; + output_highlight_rst($args{'parameterdescs'}{$parameter_name}); + print "\n"; + } + print "\n"; + + $lineprefix = $oldprefix; + output_section_rst(@_); +} + +## none mode output functions + +sub output_function_none(%) { +} + +sub output_enum_none(%) { +} + +sub output_typedef_none(%) { +} + +sub output_struct_none(%) { +} + +sub output_blockhead_none(%) { +} + +## +# generic output function for all types (function, struct/union, typedef, enum); +# calls the generated, variable output_ function name based on +# functype and output_mode +sub output_declaration { + no strict 'refs'; + my $name = shift; + my $functype = shift; + my $func = "output_${functype}_$output_mode"; + + return if (defined($nosymbol_table{$name})); + + if (($output_selection == OUTPUT_ALL) || + (($output_selection == OUTPUT_INCLUDE || + $output_selection == OUTPUT_EXPORTED) && + defined($function_table{$name})) || + ($output_selection == OUTPUT_INTERNAL && + !($functype eq "function" && defined($function_table{$name})))) + { + &$func(@_); + $section_counter++; + } +} + +## +# generic output function - calls the right one based on current output mode. +sub output_blockhead { + no strict 'refs'; + my $func = "output_blockhead_" . $output_mode; + &$func(@_); + $section_counter++; +} + +## +# takes a declaration (struct, union, enum, typedef) and +# invokes the right handler. NOT called for functions. +sub dump_declaration($$) { + no strict 'refs'; + my ($prototype, $file) = @_; + my $func = "dump_" . $decl_type; + &$func(@_); +} + +sub dump_union($$) { + dump_struct(@_); +} + +sub dump_struct($$) { + my $x = shift; + my $file = shift; + my $decl_type; + my $members; + my $type = qr{struct|union}; + # For capturing struct/union definition body, i.e. "{members*}qualifiers*" + my $qualifiers = qr{$attribute|__packed|__aligned|____cacheline_aligned_in_smp|____cacheline_aligned}; + my $definition_body = qr{\{(.*)\}\s*$qualifiers*}; + my $struct_members = qr{($type)([^\{\};]+)\{([^\{\}]*)\}([^\{\}\;]*)\;}; + + if ($x =~ /($type)\s+(\w+)\s*$definition_body/) { + $decl_type = $1; + $declaration_name = $2; + $members = $3; + } elsif ($x =~ /typedef\s+($type)\s*$definition_body\s*(\w+)\s*;/) { + $decl_type = $1; + $declaration_name = $3; + $members = $2; + } + + if ($members) { + if ($identifier ne $declaration_name) { + print STDERR "${file}:$.: warning: expecting prototype for $decl_type $identifier. Prototype was for $decl_type $declaration_name instead\n"; + return; + } + + # ignore members marked private: + $members =~ s/\/\*\s*private:.*?\/\*\s*public:.*?\*\///gosi; + $members =~ s/\/\*\s*private:.*//gosi; + # strip comments: + $members =~ s/\/\*.*?\*\///gos; + # strip attributes + $members =~ s/\s*$attribute/ /gi; + $members =~ s/\s*__aligned\s*\([^;]*\)/ /gos; + $members =~ s/\s*__packed\s*/ /gos; + $members =~ s/\s*CRYPTO_MINALIGN_ATTR/ /gos; + $members =~ s/\s*____cacheline_aligned_in_smp/ /gos; + $members =~ s/\s*____cacheline_aligned/ /gos; + # unwrap struct_group(): + # - first eat non-declaration parameters and rewrite for final match + # - then remove macro, outer parens, and trailing semicolon + $members =~ s/\bstruct_group\s*\(([^,]*,)/STRUCT_GROUP(/gos; + $members =~ s/\bstruct_group_(attr|tagged)\s*\(([^,]*,){2}/STRUCT_GROUP(/gos; + $members =~ s/\b__struct_group\s*\(([^,]*,){3}/STRUCT_GROUP(/gos; + $members =~ s/\bSTRUCT_GROUP(\(((?:(?>[^)(]+)|(?1))*)\))[^;]*;/$2/gos; + + my $args = qr{([^,)]+)}; + # replace DECLARE_BITMAP + $members =~ s/__ETHTOOL_DECLARE_LINK_MODE_MASK\s*\(([^\)]+)\)/DECLARE_BITMAP($1, __ETHTOOL_LINK_MODE_MASK_NBITS)/gos; + $members =~ s/DECLARE_PHY_INTERFACE_MASK\s*\(([^\)]+)\)/DECLARE_BITMAP($1, PHY_INTERFACE_MODE_MAX)/gos; + $members =~ s/DECLARE_BITMAP\s*\($args,\s*$args\)/unsigned long $1\[BITS_TO_LONGS($2)\]/gos; + # replace DECLARE_HASHTABLE + $members =~ s/DECLARE_HASHTABLE\s*\($args,\s*$args\)/unsigned long $1\[1 << (($2) - 1)\]/gos; + # replace DECLARE_KFIFO + $members =~ s/DECLARE_KFIFO\s*\($args,\s*$args,\s*$args\)/$2 \*$1/gos; + # replace DECLARE_KFIFO_PTR + $members =~ s/DECLARE_KFIFO_PTR\s*\($args,\s*$args\)/$2 \*$1/gos; + # replace DECLARE_FLEX_ARRAY + $members =~ s/(?:__)?DECLARE_FLEX_ARRAY\s*\($args,\s*$args\)/$1 $2\[\]/gos; + my $declaration = $members; + + # Split nested struct/union elements as newer ones + while ($members =~ m/$struct_members/) { + my $newmember; + my $maintype = $1; + my $ids = $4; + my $content = $3; + foreach my $id(split /,/, $ids) { + $newmember .= "$maintype $id; "; + + $id =~ s/[:\[].*//; + $id =~ s/^\s*\**(\S+)\s*/$1/; + foreach my $arg (split /;/, $content) { + next if ($arg =~ m/^\s*$/); + if ($arg =~ m/^([^\(]+\(\*?\s*)([\w\.]*)(\s*\).*)/) { + # pointer-to-function + my $type = $1; + my $name = $2; + my $extra = $3; + next if (!$name); + if ($id =~ m/^\s*$/) { + # anonymous struct/union + $newmember .= "$type$name$extra; "; + } else { + $newmember .= "$type$id.$name$extra; "; + } + } else { + my $type; + my $names; + $arg =~ s/^\s+//; + $arg =~ s/\s+$//; + # Handle bitmaps + $arg =~ s/:\s*\d+\s*//g; + # Handle arrays + $arg =~ s/\[.*\]//g; + # The type may have multiple words, + # and multiple IDs can be defined, like: + # const struct foo, *bar, foobar + # So, we remove spaces when parsing the + # names, in order to match just names + # and commas for the names + $arg =~ s/\s*,\s*/,/g; + if ($arg =~ m/(.*)\s+([\S+,]+)/) { + $type = $1; + $names = $2; + } else { + $newmember .= "$arg; "; + next; + } + foreach my $name (split /,/, $names) { + $name =~ s/^\s*\**(\S+)\s*/$1/; + next if (($name =~ m/^\s*$/)); + if ($id =~ m/^\s*$/) { + # anonymous struct/union + $newmember .= "$type $name; "; + } else { + $newmember .= "$type $id.$name; "; + } + } + } + } + } + $members =~ s/$struct_members/$newmember/; + } + + # Ignore other nested elements, like enums + $members =~ s/(\{[^\{\}]*\})//g; + + create_parameterlist($members, ';', $file, $declaration_name); + check_sections($file, $declaration_name, $decl_type, $sectcheck, $struct_actual); + + # Adjust declaration for better display + $declaration =~ s/([\{;])/$1\n/g; + $declaration =~ s/\}\s+;/};/g; + # Better handle inlined enums + do {} while ($declaration =~ s/(enum\s+\{[^\}]+),([^\n])/$1,\n$2/); + + my @def_args = split /\n/, $declaration; + my $level = 1; + $declaration = ""; + foreach my $clause (@def_args) { + $clause =~ s/^\s+//; + $clause =~ s/\s+$//; + $clause =~ s/\s+/ /; + next if (!$clause); + $level-- if ($clause =~ m/(\})/ && $level > 1); + if (!($clause =~ m/^\s*#/)) { + $declaration .= "\t" x $level; + } + $declaration .= "\t" . $clause . "\n"; + $level++ if ($clause =~ m/(\{)/ && !($clause =~m/\}/)); + } + output_declaration($declaration_name, + 'struct', + {'struct' => $declaration_name, + 'module' => $modulename, + 'definition' => $declaration, + 'parameterlist' => \@parameterlist, + 'parameterdescs' => \%parameterdescs, + 'parametertypes' => \%parametertypes, + 'sectionlist' => \@sectionlist, + 'sections' => \%sections, + 'purpose' => $declaration_purpose, + 'type' => $decl_type + }); + } + else { + print STDERR "${file}:$.: error: Cannot parse struct or union!\n"; + ++$errors; + } +} + + +sub show_warnings($$) { + my $functype = shift; + my $name = shift; + + return 0 if (defined($nosymbol_table{$name})); + + return 1 if ($output_selection == OUTPUT_ALL); + + if ($output_selection == OUTPUT_EXPORTED) { + if (defined($function_table{$name})) { + return 1; + } else { + return 0; + } + } + if ($output_selection == OUTPUT_INTERNAL) { + if (!($functype eq "function" && defined($function_table{$name}))) { + return 1; + } else { + return 0; + } + } + if ($output_selection == OUTPUT_INCLUDE) { + if (defined($function_table{$name})) { + return 1; + } else { + return 0; + } + } + die("Please add the new output type at show_warnings()"); +} + +sub dump_enum($$) { + my $x = shift; + my $file = shift; + my $members; + + + $x =~ s@/\*.*?\*/@@gos; # strip comments. + # strip #define macros inside enums + $x =~ s@#\s*((define|ifdef)\s+|endif)[^;]*;@@gos; + + if ($x =~ /typedef\s+enum\s*\{(.*)\}\s*(\w*)\s*;/) { + $declaration_name = $2; + $members = $1; + } elsif ($x =~ /enum\s+(\w*)\s*\{(.*)\}/) { + $declaration_name = $1; + $members = $2; + } + + if ($members) { + if ($identifier ne $declaration_name) { + if ($identifier eq "") { + print STDERR "${file}:$.: warning: wrong kernel-doc identifier on line:\n"; + } else { + print STDERR "${file}:$.: warning: expecting prototype for enum $identifier. Prototype was for enum $declaration_name instead\n"; + } + return; + } + $declaration_name = "(anonymous)" if ($declaration_name eq ""); + + my %_members; + + $members =~ s/\s+$//; + + foreach my $arg (split ',', $members) { + $arg =~ s/^\s*(\w+).*/$1/; + push @parameterlist, $arg; + if (!$parameterdescs{$arg}) { + $parameterdescs{$arg} = $undescribed; + if (show_warnings("enum", $declaration_name)) { + print STDERR "${file}:$.: warning: Enum value '$arg' not described in enum '$declaration_name'\n"; + } + } + $_members{$arg} = 1; + } + + while (my ($k, $v) = each %parameterdescs) { + if (!exists($_members{$k})) { + if (show_warnings("enum", $declaration_name)) { + print STDERR "${file}:$.: warning: Excess enum value '$k' description in '$declaration_name'\n"; + } + } + } + + output_declaration($declaration_name, + 'enum', + {'enum' => $declaration_name, + 'module' => $modulename, + 'parameterlist' => \@parameterlist, + 'parameterdescs' => \%parameterdescs, + 'sectionlist' => \@sectionlist, + 'sections' => \%sections, + 'purpose' => $declaration_purpose + }); + } else { + print STDERR "${file}:$.: error: Cannot parse enum!\n"; + ++$errors; + } +} + +my $typedef_type = qr { ((?:\s+[\w\*]+\b){1,8})\s* }x; +my $typedef_ident = qr { \*?\s*(\w\S+)\s* }x; +my $typedef_args = qr { \s*\((.*)\); }x; + +my $typedef1 = qr { typedef$typedef_type\($typedef_ident\)$typedef_args }x; +my $typedef2 = qr { typedef$typedef_type$typedef_ident$typedef_args }x; + +sub dump_typedef($$) { + my $x = shift; + my $file = shift; + + $x =~ s@/\*.*?\*/@@gos; # strip comments. + + # Parse function typedef prototypes + if ($x =~ $typedef1 || $x =~ $typedef2) { + $return_type = $1; + $declaration_name = $2; + my $args = $3; + $return_type =~ s/^\s+//; + + if ($identifier ne $declaration_name) { + print STDERR "${file}:$.: warning: expecting prototype for typedef $identifier. Prototype was for typedef $declaration_name instead\n"; + return; + } + + create_parameterlist($args, ',', $file, $declaration_name); + + output_declaration($declaration_name, + 'function', + {'function' => $declaration_name, + 'typedef' => 1, + 'module' => $modulename, + 'functiontype' => $return_type, + 'parameterlist' => \@parameterlist, + 'parameterdescs' => \%parameterdescs, + 'parametertypes' => \%parametertypes, + 'sectionlist' => \@sectionlist, + 'sections' => \%sections, + 'purpose' => $declaration_purpose + }); + return; + } + + while (($x =~ /\(*.\)\s*;$/) || ($x =~ /\[*.\]\s*;$/)) { + $x =~ s/\(*.\)\s*;$/;/; + $x =~ s/\[*.\]\s*;$/;/; + } + + if ($x =~ /typedef.*\s+(\w+)\s*;/) { + $declaration_name = $1; + + if ($identifier ne $declaration_name) { + print STDERR "${file}:$.: warning: expecting prototype for typedef $identifier. Prototype was for typedef $declaration_name instead\n"; + return; + } + + output_declaration($declaration_name, + 'typedef', + {'typedef' => $declaration_name, + 'module' => $modulename, + 'sectionlist' => \@sectionlist, + 'sections' => \%sections, + 'purpose' => $declaration_purpose + }); + } + else { + print STDERR "${file}:$.: error: Cannot parse typedef!\n"; + ++$errors; + } +} + +sub save_struct_actual($) { + my $actual = shift; + + # strip all spaces from the actual param so that it looks like one string item + $actual =~ s/\s*//g; + $struct_actual = $struct_actual . $actual . " "; +} + +sub create_parameterlist($$$$) { + my $args = shift; + my $splitter = shift; + my $file = shift; + my $declaration_name = shift; + my $type; + my $param; + + # temporarily replace commas inside function pointer definition + my $arg_expr = qr{\([^\),]+}; + while ($args =~ /$arg_expr,/) { + $args =~ s/($arg_expr),/$1#/g; + } + + foreach my $arg (split($splitter, $args)) { + # strip comments + $arg =~ s/\/\*.*\*\///; + # strip leading/trailing spaces + $arg =~ s/^\s*//; + $arg =~ s/\s*$//; + $arg =~ s/\s+/ /; + + if ($arg =~ /^#/) { + # Treat preprocessor directive as a typeless variable just to fill + # corresponding data structures "correctly". Catch it later in + # output_* subs. + push_parameter($arg, "", "", $file); + } elsif ($arg =~ m/\(.+\)\s*\(/) { + # pointer-to-function + $arg =~ tr/#/,/; + $arg =~ m/[^\(]+\(\*?\s*([\w\[\]\.]*)\s*\)/; + $param = $1; + $type = $arg; + $type =~ s/([^\(]+\(\*?)\s*$param/$1/; + save_struct_actual($param); + push_parameter($param, $type, $arg, $file, $declaration_name); + } elsif ($arg) { + $arg =~ s/\s*:\s*/:/g; + $arg =~ s/\s*\[/\[/g; + + my @args = split('\s*,\s*', $arg); + if ($args[0] =~ m/\*/) { + $args[0] =~ s/(\*+)\s*/ $1/; + } + + my @first_arg; + if ($args[0] =~ /^(.*\s+)(.*?\[.*\].*)$/) { + shift @args; + push(@first_arg, split('\s+', $1)); + push(@first_arg, $2); + } else { + @first_arg = split('\s+', shift @args); + } + + unshift(@args, pop @first_arg); + $type = join " ", @first_arg; + + foreach $param (@args) { + if ($param =~ m/^(\*+)\s*(.*)/) { + save_struct_actual($2); + + push_parameter($2, "$type $1", $arg, $file, $declaration_name); + } + elsif ($param =~ m/(.*?):(\d+)/) { + if ($type ne "") { # skip unnamed bit-fields + save_struct_actual($1); + push_parameter($1, "$type:$2", $arg, $file, $declaration_name) + } + } + else { + save_struct_actual($param); + push_parameter($param, $type, $arg, $file, $declaration_name); + } + } + } + } +} + +sub push_parameter($$$$$) { + my $param = shift; + my $type = shift; + my $org_arg = shift; + my $file = shift; + my $declaration_name = shift; + + if (($anon_struct_union == 1) && ($type eq "") && + ($param eq "}")) { + return; # ignore the ending }; from anon. struct/union + } + + $anon_struct_union = 0; + $param =~ s/[\[\)].*//; + + if ($type eq "" && $param =~ /\.\.\.$/) + { + if (!$param =~ /\w\.\.\.$/) { + # handles unnamed variable parameters + $param = "..."; + } + elsif ($param =~ /\w\.\.\.$/) { + # for named variable parameters of the form `x...`, remove the dots + $param =~ s/\.\.\.$//; + } + if (!defined $parameterdescs{$param} || $parameterdescs{$param} eq "") { + $parameterdescs{$param} = "variable arguments"; + } + } + elsif ($type eq "" && ($param eq "" or $param eq "void")) + { + $param="void"; + $parameterdescs{void} = "no arguments"; + } + elsif ($type eq "" && ($param eq "struct" or $param eq "union")) + # handle unnamed (anonymous) union or struct: + { + $type = $param; + $param = "{unnamed_" . $param . "}"; + $parameterdescs{$param} = "anonymous\n"; + $anon_struct_union = 1; + } + + # warn if parameter has no description + # (but ignore ones starting with # as these are not parameters + # but inline preprocessor statements); + # Note: It will also ignore void params and unnamed structs/unions + if (!defined $parameterdescs{$param} && $param !~ /^#/) { + $parameterdescs{$param} = $undescribed; + + if (show_warnings($type, $declaration_name) && $param !~ /\./) { + print STDERR + "${file}:$.: warning: Function parameter or member '$param' not described in '$declaration_name'\n"; + ++$warnings; + } + } + + # strip spaces from $param so that it is one continuous string + # on @parameterlist; + # this fixes a problem where check_sections() cannot find + # a parameter like "addr[6 + 2]" because it actually appears + # as "addr[6", "+", "2]" on the parameter list; + # but it's better to maintain the param string unchanged for output, + # so just weaken the string compare in check_sections() to ignore + # "[blah" in a parameter string; + ###$param =~ s/\s*//g; + push @parameterlist, $param; + $org_arg =~ s/\s\s+/ /g; + $parametertypes{$param} = $org_arg; +} + +sub check_sections($$$$$) { + my ($file, $decl_name, $decl_type, $sectcheck, $prmscheck) = @_; + my @sects = split ' ', $sectcheck; + my @prms = split ' ', $prmscheck; + my $err; + my ($px, $sx); + my $prm_clean; # strip trailing "[array size]" and/or beginning "*" + + foreach $sx (0 .. $#sects) { + $err = 1; + foreach $px (0 .. $#prms) { + $prm_clean = $prms[$px]; + $prm_clean =~ s/\[.*\]//; + $prm_clean =~ s/$attribute//i; + # ignore array size in a parameter string; + # however, the original param string may contain + # spaces, e.g.: addr[6 + 2] + # and this appears in @prms as "addr[6" since the + # parameter list is split at spaces; + # hence just ignore "[..." for the sections check; + $prm_clean =~ s/\[.*//; + + ##$prm_clean =~ s/^\**//; + if ($prm_clean eq $sects[$sx]) { + $err = 0; + last; + } + } + if ($err) { + if ($decl_type eq "function") { + print STDERR "${file}:$.: warning: " . + "Excess function parameter " . + "'$sects[$sx]' " . + "description in '$decl_name'\n"; + ++$warnings; + } + } + } +} + +## +# Checks the section describing the return value of a function. +sub check_return_section { + my $file = shift; + my $declaration_name = shift; + my $return_type = shift; + + # Ignore an empty return type (It's a macro) + # Ignore functions with a "void" return type. (But don't ignore "void *") + if (($return_type eq "") || ($return_type =~ /void\s*\w*\s*$/)) { + return; + } + + if (!defined($sections{$section_return}) || + $sections{$section_return} eq "") { + print STDERR "${file}:$.: warning: " . + "No description found for return value of " . + "'$declaration_name'\n"; + ++$warnings; + } +} + +## +# takes a function prototype and the name of the current file being +# processed and spits out all the details stored in the global +# arrays/hashes. +sub dump_function($$) { + my $prototype = shift; + my $file = shift; + my $noret = 0; + + print_lineno($new_start_line); + + $prototype =~ s/^static +//; + $prototype =~ s/^extern +//; + $prototype =~ s/^asmlinkage +//; + $prototype =~ s/^inline +//; + $prototype =~ s/^__inline__ +//; + $prototype =~ s/^__inline +//; + $prototype =~ s/^__always_inline +//; + $prototype =~ s/^noinline +//; + $prototype =~ s/__init +//; + $prototype =~ s/__init_or_module +//; + $prototype =~ s/__deprecated +//; + $prototype =~ s/__flatten +//; + $prototype =~ s/__meminit +//; + $prototype =~ s/__must_check +//; + $prototype =~ s/__weak +//; + $prototype =~ s/__sched +//; + $prototype =~ s/__printf\s*\(\s*\d*\s*,\s*\d*\s*\) +//; + $prototype =~ s/__alloc_size\s*\(\s*\d+\s*(?:,\s*\d+\s*)?\) +//; + my $define = $prototype =~ s/^#\s*define\s+//; #ak added + $prototype =~ s/__attribute_const__ +//; + $prototype =~ s/__attribute__\s*\(\( + (?: + [\w\s]++ # attribute name + (?:\([^)]*+\))? # attribute arguments + \s*+,? # optional comma at the end + )+ + \)\)\s+//x; + + # Yes, this truly is vile. We are looking for: + # 1. Return type (may be nothing if we're looking at a macro) + # 2. Function name + # 3. Function parameters. + # + # All the while we have to watch out for function pointer parameters + # (which IIRC is what the two sections are for), C types (these + # regexps don't even start to express all the possibilities), and + # so on. + # + # If you mess with these regexps, it's a good idea to check that + # the following functions' documentation still comes out right: + # - parport_register_device (function pointer parameters) + # - atomic_set (macro) + # - pci_match_device, __copy_to_user (long return type) + my $name = qr{[a-zA-Z0-9_~:]+}; + my $prototype_end1 = qr{[^\(]*}; + my $prototype_end2 = qr{[^\{]*}; + my $prototype_end = qr{\(($prototype_end1|$prototype_end2)\)}; + my $type1 = qr{[\w\s]+}; + my $type2 = qr{$type1\*+}; + + if ($define && $prototype =~ m/^()($name)\s+/) { + # This is an object-like macro, it has no return type and no parameter + # list. + # Function-like macros are not allowed to have spaces between + # declaration_name and opening parenthesis (notice the \s+). + $return_type = $1; + $declaration_name = $2; + $noret = 1; + } elsif ($prototype =~ m/^()($name)\s*$prototype_end/ || + $prototype =~ m/^($type1)\s+($name)\s*$prototype_end/ || + $prototype =~ m/^($type2+)\s*($name)\s*$prototype_end/) { + $return_type = $1; + $declaration_name = $2; + my $args = $3; + + create_parameterlist($args, ',', $file, $declaration_name); + } else { + print STDERR "${file}:$.: warning: cannot understand function prototype: '$prototype'\n"; + return; + } + + if ($identifier ne $declaration_name) { + print STDERR "${file}:$.: warning: expecting prototype for $identifier(). Prototype was for $declaration_name() instead\n"; + return; + } + + my $prms = join " ", @parameterlist; + check_sections($file, $declaration_name, "function", $sectcheck, $prms); + + # This check emits a lot of warnings at the moment, because many + # functions don't have a 'Return' doc section. So until the number + # of warnings goes sufficiently down, the check is only performed in + # verbose mode. + # TODO: always perform the check. + if ($verbose && !$noret) { + check_return_section($file, $declaration_name, $return_type); + } + + # The function parser can be called with a typedef parameter. + # Handle it. + if ($return_type =~ /typedef/) { + output_declaration($declaration_name, + 'function', + {'function' => $declaration_name, + 'typedef' => 1, + 'module' => $modulename, + 'functiontype' => $return_type, + 'parameterlist' => \@parameterlist, + 'parameterdescs' => \%parameterdescs, + 'parametertypes' => \%parametertypes, + 'sectionlist' => \@sectionlist, + 'sections' => \%sections, + 'purpose' => $declaration_purpose + }); + } else { + output_declaration($declaration_name, + 'function', + {'function' => $declaration_name, + 'module' => $modulename, + 'functiontype' => $return_type, + 'parameterlist' => \@parameterlist, + 'parameterdescs' => \%parameterdescs, + 'parametertypes' => \%parametertypes, + 'sectionlist' => \@sectionlist, + 'sections' => \%sections, + 'purpose' => $declaration_purpose + }); + } +} + +sub reset_state { + $function = ""; + %parameterdescs = (); + %parametertypes = (); + @parameterlist = (); + %sections = (); + @sectionlist = (); + $sectcheck = ""; + $struct_actual = ""; + $prototype = ""; + + $state = STATE_NORMAL; + $inline_doc_state = STATE_INLINE_NA; +} + +sub tracepoint_munge($) { + my $file = shift; + my $tracepointname = 0; + my $tracepointargs = 0; + + if ($prototype =~ m/TRACE_EVENT\((.*?),/) { + $tracepointname = $1; + } + if ($prototype =~ m/DEFINE_SINGLE_EVENT\((.*?),/) { + $tracepointname = $1; + } + if ($prototype =~ m/DEFINE_EVENT\((.*?),(.*?),/) { + $tracepointname = $2; + } + $tracepointname =~ s/^\s+//; #strip leading whitespace + if ($prototype =~ m/TP_PROTO\((.*?)\)/) { + $tracepointargs = $1; + } + if (($tracepointname eq 0) || ($tracepointargs eq 0)) { + print STDERR "${file}:$.: warning: Unrecognized tracepoint format: \n". + "$prototype\n"; + } else { + $prototype = "static inline void trace_$tracepointname($tracepointargs)"; + $identifier = "trace_$identifier"; + } +} + +sub syscall_munge() { + my $void = 0; + + $prototype =~ s@[\r\n]+@ @gos; # strip newlines/CR's +## if ($prototype =~ m/SYSCALL_DEFINE0\s*\(\s*(a-zA-Z0-9_)*\s*\)/) { + if ($prototype =~ m/SYSCALL_DEFINE0/) { + $void = 1; +## $prototype = "long sys_$1(void)"; + } + + $prototype =~ s/SYSCALL_DEFINE.*\(/long sys_/; # fix return type & func name + if ($prototype =~ m/long (sys_.*?),/) { + $prototype =~ s/,/\(/; + } elsif ($void) { + $prototype =~ s/\)/\(void\)/; + } + + # now delete all of the odd-number commas in $prototype + # so that arg types & arg names don't have a comma between them + my $count = 0; + my $len = length($prototype); + if ($void) { + $len = 0; # skip the for-loop + } + for (my $ix = 0; $ix < $len; $ix++) { + if (substr($prototype, $ix, 1) eq ',') { + $count++; + if ($count % 2 == 1) { + substr($prototype, $ix, 1) = ' '; + } + } + } +} + +sub process_proto_function($$) { + my $x = shift; + my $file = shift; + + $x =~ s@\/\/.*$@@gos; # strip C99-style comments to end of line + + if ($x =~ m#\s*/\*\s+MACDOC\s*#io || ($x =~ /^#/ && $x !~ /^#\s*define/)) { + # do nothing + } + elsif ($x =~ /([^\{]*)/) { + $prototype .= $1; + } + + if (($x =~ /\{/) || ($x =~ /\#\s*define/) || ($x =~ /;/)) { + $prototype =~ s@/\*.*?\*/@@gos; # strip comments. + $prototype =~ s@[\r\n]+@ @gos; # strip newlines/cr's. + $prototype =~ s@^\s+@@gos; # strip leading spaces + + # Handle prototypes for function pointers like: + # int (*pcs_config)(struct foo) + $prototype =~ s@^(\S+\s+)\(\s*\*(\S+)\)@$1$2@gos; + + if ($prototype =~ /SYSCALL_DEFINE/) { + syscall_munge(); + } + if ($prototype =~ /TRACE_EVENT/ || $prototype =~ /DEFINE_EVENT/ || + $prototype =~ /DEFINE_SINGLE_EVENT/) + { + tracepoint_munge($file); + } + dump_function($prototype, $file); + reset_state(); + } +} + +sub process_proto_type($$) { + my $x = shift; + my $file = shift; + + $x =~ s@[\r\n]+@ @gos; # strip newlines/cr's. + $x =~ s@^\s+@@gos; # strip leading spaces + $x =~ s@\s+$@@gos; # strip trailing spaces + $x =~ s@\/\/.*$@@gos; # strip C99-style comments to end of line + + if ($x =~ /^#/) { + # To distinguish preprocessor directive from regular declaration later. + $x .= ";"; + } + + while (1) { + if ( $x =~ /([^\{\};]*)([\{\};])(.*)/ ) { + if( length $prototype ) { + $prototype .= " " + } + $prototype .= $1 . $2; + ($2 eq '{') && $brcount++; + ($2 eq '}') && $brcount--; + if (($2 eq ';') && ($brcount == 0)) { + dump_declaration($prototype, $file); + reset_state(); + last; + } + $x = $3; + } else { + $prototype .= $x; + last; + } + } +} + + +sub map_filename($) { + my $file; + my ($orig_file) = @_; + + if (defined($ENV{'SRCTREE'})) { + $file = "$ENV{'SRCTREE'}" . "/" . $orig_file; + } else { + $file = $orig_file; + } + + if (defined($source_map{$file})) { + $file = $source_map{$file}; + } + + return $file; +} + +sub process_export_file($) { + my ($orig_file) = @_; + my $file = map_filename($orig_file); + + if (!open(IN,"<$file")) { + print STDERR "Error: Cannot open file $file\n"; + ++$errors; + return; + } + + while (<IN>) { + if (/$export_symbol/) { + next if (defined($nosymbol_table{$2})); + $function_table{$2} = 1; + } + } + + close(IN); +} + +# +# Parsers for the various processing states. +# +# STATE_NORMAL: looking for the /** to begin everything. +# +sub process_normal() { + if (/$doc_start/o) { + $state = STATE_NAME; # next line is always the function name + $in_doc_sect = 0; + $declaration_start_line = $. + 1; + } +} + +# +# STATE_NAME: Looking for the "name - description" line +# +sub process_name($$) { + my $file = shift; + my $descr; + + if (/$doc_block/o) { + $state = STATE_DOCBLOCK; + $contents = ""; + $new_start_line = $.; + + if ( $1 eq "" ) { + $section = $section_intro; + } else { + $section = $1; + } + } elsif (/$doc_decl/o) { + $identifier = $1; + my $is_kernel_comment = 0; + my $decl_start = qr{$doc_com}; + # test for pointer declaration type, foo * bar() - desc + my $fn_type = qr{\w+\s*\*\s*}; + my $parenthesis = qr{\(\w*\)}; + my $decl_end = qr{[-:].*}; + if (/^$decl_start([\w\s]+?)$parenthesis?\s*$decl_end?$/) { + $identifier = $1; + } + if ($identifier =~ m/^(struct|union|enum|typedef)\b\s*(\S*)/) { + $decl_type = $1; + $identifier = $2; + $is_kernel_comment = 1; + } + # Look for foo() or static void foo() - description; or misspelt + # identifier + elsif (/^$decl_start$fn_type?(\w+)\s*$parenthesis?\s*$decl_end?$/ || + /^$decl_start$fn_type?(\w+.*)$parenthesis?\s*$decl_end$/) { + $identifier = $1; + $decl_type = 'function'; + $identifier =~ s/^define\s+//; + $is_kernel_comment = 1; + } + $identifier =~ s/\s+$//; + + $state = STATE_BODY; + # if there's no @param blocks need to set up default section + # here + $contents = ""; + $section = $section_default; + $new_start_line = $. + 1; + if (/[-:](.*)/) { + # strip leading/trailing/multiple spaces + $descr= $1; + $descr =~ s/^\s*//; + $descr =~ s/\s*$//; + $descr =~ s/\s+/ /g; + $declaration_purpose = $descr; + $state = STATE_BODY_MAYBE; + } else { + $declaration_purpose = ""; + } + + if (!$is_kernel_comment) { + print STDERR "${file}:$.: warning: This comment starts with '/**', but isn't a kernel-doc comment. Refer Documentation/doc-guide/kernel-doc.rst\n"; + print STDERR $_; + ++$warnings; + $state = STATE_NORMAL; + } + + if (($declaration_purpose eq "") && $verbose) { + print STDERR "${file}:$.: warning: missing initial short description on line:\n"; + print STDERR $_; + ++$warnings; + } + + if ($identifier eq "" && $decl_type ne "enum") { + print STDERR "${file}:$.: warning: wrong kernel-doc identifier on line:\n"; + print STDERR $_; + ++$warnings; + $state = STATE_NORMAL; + } + + if ($verbose) { + print STDERR "${file}:$.: info: Scanning doc for $decl_type $identifier\n"; + } + } else { + print STDERR "${file}:$.: warning: Cannot understand $_ on line $.", + " - I thought it was a doc line\n"; + ++$warnings; + $state = STATE_NORMAL; + } +} + + +# +# STATE_BODY and STATE_BODY_MAYBE: the bulk of a kerneldoc comment. +# +sub process_body($$) { + my $file = shift; + + # Until all named variable macro parameters are + # documented using the bare name (`x`) rather than with + # dots (`x...`), strip the dots: + if ($section =~ /\w\.\.\.$/) { + $section =~ s/\.\.\.$//; + + if ($verbose) { + print STDERR "${file}:$.: warning: Variable macro arguments should be documented without dots\n"; + ++$warnings; + } + } + + if ($state == STATE_BODY_WITH_BLANK_LINE && /^\s*\*\s?\S/) { + dump_section($file, $section, $contents); + $section = $section_default; + $new_start_line = $.; + $contents = ""; + } + + if (/$doc_sect/i) { # case insensitive for supported section names + $newsection = $1; + $newcontents = $2; + + # map the supported section names to the canonical names + if ($newsection =~ m/^description$/i) { + $newsection = $section_default; + } elsif ($newsection =~ m/^context$/i) { + $newsection = $section_context; + } elsif ($newsection =~ m/^returns?$/i) { + $newsection = $section_return; + } elsif ($newsection =~ m/^\@return$/) { + # special: @return is a section, not a param description + $newsection = $section_return; + } + + if (($contents ne "") && ($contents ne "\n")) { + if (!$in_doc_sect && $verbose) { + print STDERR "${file}:$.: warning: contents before sections\n"; + ++$warnings; + } + dump_section($file, $section, $contents); + $section = $section_default; + } + + $in_doc_sect = 1; + $state = STATE_BODY; + $contents = $newcontents; + $new_start_line = $.; + while (substr($contents, 0, 1) eq " ") { + $contents = substr($contents, 1); + } + if ($contents ne "") { + $contents .= "\n"; + } + $section = $newsection; + $leading_space = undef; + } elsif (/$doc_end/) { + if (($contents ne "") && ($contents ne "\n")) { + dump_section($file, $section, $contents); + $section = $section_default; + $contents = ""; + } + # look for doc_com + <text> + doc_end: + if ($_ =~ m'\s*\*\s*[a-zA-Z_0-9:\.]+\*/') { + print STDERR "${file}:$.: warning: suspicious ending line: $_"; + ++$warnings; + } + + $prototype = ""; + $state = STATE_PROTO; + $brcount = 0; + $new_start_line = $. + 1; + } elsif (/$doc_content/) { + if ($1 eq "") { + if ($section eq $section_context) { + dump_section($file, $section, $contents); + $section = $section_default; + $contents = ""; + $new_start_line = $.; + $state = STATE_BODY; + } else { + if ($section ne $section_default) { + $state = STATE_BODY_WITH_BLANK_LINE; + } else { + $state = STATE_BODY; + } + $contents .= "\n"; + } + } elsif ($state == STATE_BODY_MAYBE) { + # Continued declaration purpose + chomp($declaration_purpose); + $declaration_purpose .= " " . $1; + $declaration_purpose =~ s/\s+/ /g; + } else { + my $cont = $1; + if ($section =~ m/^@/ || $section eq $section_context) { + if (!defined $leading_space) { + if ($cont =~ m/^(\s+)/) { + $leading_space = $1; + } else { + $leading_space = ""; + } + } + $cont =~ s/^$leading_space//; + } + $contents .= $cont . "\n"; + } + } else { + # i dont know - bad line? ignore. + print STDERR "${file}:$.: warning: bad line: $_"; + ++$warnings; + } +} + + +# +# STATE_PROTO: reading a function/whatever prototype. +# +sub process_proto($$) { + my $file = shift; + + if (/$doc_inline_oneline/) { + $section = $1; + $contents = $2; + if ($contents ne "") { + $contents .= "\n"; + dump_section($file, $section, $contents); + $section = $section_default; + $contents = ""; + } + } elsif (/$doc_inline_start/) { + $state = STATE_INLINE; + $inline_doc_state = STATE_INLINE_NAME; + } elsif ($decl_type eq 'function') { + process_proto_function($_, $file); + } else { + process_proto_type($_, $file); + } +} + +# +# STATE_DOCBLOCK: within a DOC: block. +# +sub process_docblock($$) { + my $file = shift; + + if (/$doc_end/) { + dump_doc_section($file, $section, $contents); + $section = $section_default; + $contents = ""; + $function = ""; + %parameterdescs = (); + %parametertypes = (); + @parameterlist = (); + %sections = (); + @sectionlist = (); + $prototype = ""; + $state = STATE_NORMAL; + } elsif (/$doc_content/) { + if ( $1 eq "" ) { + $contents .= $blankline; + } else { + $contents .= $1 . "\n"; + } + } +} + +# +# STATE_INLINE: docbook comments within a prototype. +# +sub process_inline($$) { + my $file = shift; + + # First line (state 1) needs to be a @parameter + if ($inline_doc_state == STATE_INLINE_NAME && /$doc_inline_sect/o) { + $section = $1; + $contents = $2; + $new_start_line = $.; + if ($contents ne "") { + while (substr($contents, 0, 1) eq " ") { + $contents = substr($contents, 1); + } + $contents .= "\n"; + } + $inline_doc_state = STATE_INLINE_TEXT; + # Documentation block end */ + } elsif (/$doc_inline_end/) { + if (($contents ne "") && ($contents ne "\n")) { + dump_section($file, $section, $contents); + $section = $section_default; + $contents = ""; + } + $state = STATE_PROTO; + $inline_doc_state = STATE_INLINE_NA; + # Regular text + } elsif (/$doc_content/) { + if ($inline_doc_state == STATE_INLINE_TEXT) { + $contents .= $1 . "\n"; + # nuke leading blank lines + if ($contents =~ /^\s*$/) { + $contents = ""; + } + } elsif ($inline_doc_state == STATE_INLINE_NAME) { + $inline_doc_state = STATE_INLINE_ERROR; + print STDERR "${file}:$.: warning: "; + print STDERR "Incorrect use of kernel-doc format: $_"; + ++$warnings; + } + } +} + + +sub process_file($) { + my $file; + my $initial_section_counter = $section_counter; + my ($orig_file) = @_; + + $file = map_filename($orig_file); + + if (!open(IN_FILE,"<$file")) { + print STDERR "Error: Cannot open file $file\n"; + ++$errors; + return; + } + + $. = 1; + + $section_counter = 0; + while (<IN_FILE>) { + while (s/\\\s*$//) { + $_ .= <IN_FILE>; + } + # Replace tabs by spaces + while ($_ =~ s/\t+/' ' x (length($&) * 8 - length($`) % 8)/e) {}; + # Hand this line to the appropriate state handler + if ($state == STATE_NORMAL) { + process_normal(); + } elsif ($state == STATE_NAME) { + process_name($file, $_); + } elsif ($state == STATE_BODY || $state == STATE_BODY_MAYBE || + $state == STATE_BODY_WITH_BLANK_LINE) { + process_body($file, $_); + } elsif ($state == STATE_INLINE) { # scanning for inline parameters + process_inline($file, $_); + } elsif ($state == STATE_PROTO) { + process_proto($file, $_); + } elsif ($state == STATE_DOCBLOCK) { + process_docblock($file, $_); + } + } + + # Make sure we got something interesting. + if ($initial_section_counter == $section_counter && $ + output_mode ne "none") { + if ($output_selection == OUTPUT_INCLUDE) { + print STDERR "${file}:1: warning: '$_' not found\n" + for keys %function_table; + } + else { + print STDERR "${file}:1: warning: no structured comments found\n"; + } + } + close IN_FILE; +} + + +if ($output_mode eq "rst") { + get_sphinx_version() if (!$sphinx_major); +} + +$kernelversion = get_kernel_version(); + +# generate a sequence of code that will splice in highlighting information +# using the s// operator. +for (my $k = 0; $k < @highlights; $k++) { + my $pattern = $highlights[$k][0]; + my $result = $highlights[$k][1]; +# print STDERR "scanning pattern:$pattern, highlight:($result)\n"; + $dohighlight .= "\$contents =~ s:$pattern:$result:gs;\n"; +} + +# Read the file that maps relative names to absolute names for +# separate source and object directories and for shadow trees. +if (open(SOURCE_MAP, "<.tmp_filelist.txt")) { + my ($relname, $absname); + while(<SOURCE_MAP>) { + chop(); + ($relname, $absname) = (split())[0..1]; + $relname =~ s:^/+::; + $source_map{$relname} = $absname; + } + close(SOURCE_MAP); +} + +if ($output_selection == OUTPUT_EXPORTED || + $output_selection == OUTPUT_INTERNAL) { + + push(@export_file_list, @ARGV); + + foreach (@export_file_list) { + chomp; + process_export_file($_); + } +} + +foreach (@ARGV) { + chomp; + process_file($_); +} +if ($verbose && $errors) { + print STDERR "$errors errors\n"; +} +if ($verbose && $warnings) { + print STDERR "$warnings warnings\n"; +} + +if ($Werror && $warnings) { + print STDERR "$warnings warnings as Errors\n"; + exit($warnings); +} else { + exit($output_mode eq "none" ? 0 : $errors) +} diff --git a/doc/list-man-pages.sh b/doc/list-man-pages.sh new file mode 100755 index 0000000..fef237c --- /dev/null +++ b/doc/list-man-pages.sh @@ -0,0 +1,15 @@ +#!/bin/bash + +file=$1 + +for func in $(sed -n 's/ \* \([a-z_]*\)() -.*/\1/p' $file); do + echo ${func} +done + +for struct in $(sed -n 's/ \* struct \([a-z_]*\) -.*/\1/p' $file); do + echo ${struct} +done + +for enum in $(sed -n 's/ \* enum \([a-z_]*\) -.*/\1/p' $file); do + echo ${enum} +done diff --git a/doc/man/nvme_admin_opcode.2 b/doc/man/nvme_admin_opcode.2 new file mode 100644 index 0000000..a762b8a --- /dev/null +++ b/doc/man/nvme_admin_opcode.2 @@ -0,0 +1,216 @@ +.TH "libnvme" 9 "enum nvme_admin_opcode" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_admin_opcode \- Known NVMe admin opcodes +.SH SYNOPSIS +enum nvme_admin_opcode { +.br +.BI " nvme_admin_delete_sq" +, +.br +.br +.BI " nvme_admin_create_sq" +, +.br +.br +.BI " nvme_admin_get_log_page" +, +.br +.br +.BI " nvme_admin_delete_cq" +, +.br +.br +.BI " nvme_admin_create_cq" +, +.br +.br +.BI " nvme_admin_identify" +, +.br +.br +.BI " nvme_admin_abort_cmd" +, +.br +.br +.BI " nvme_admin_set_features" +, +.br +.br +.BI " nvme_admin_get_features" +, +.br +.br +.BI " nvme_admin_async_event" +, +.br +.br +.BI " nvme_admin_ns_mgmt" +, +.br +.br +.BI " nvme_admin_fw_commit" +, +.br +.br +.BI " nvme_admin_fw_activate" +, +.br +.br +.BI " nvme_admin_fw_download" +, +.br +.br +.BI " nvme_admin_dev_self_test" +, +.br +.br +.BI " nvme_admin_ns_attach" +, +.br +.br +.BI " nvme_admin_keep_alive" +, +.br +.br +.BI " nvme_admin_directive_send" +, +.br +.br +.BI " nvme_admin_directive_recv" +, +.br +.br +.BI " nvme_admin_virtual_mgmt" +, +.br +.br +.BI " nvme_admin_nvme_mi_send" +, +.br +.br +.BI " nvme_admin_nvme_mi_recv" +, +.br +.br +.BI " nvme_admin_capacity_mgmt" +, +.br +.br +.BI " nvme_admin_discovery_info_mgmt" +, +.br +.br +.BI " nvme_admin_fabric_zoning_recv" +, +.br +.br +.BI " nvme_admin_lockdown" +, +.br +.br +.BI " nvme_admin_fabric_zoning_lookup" +, +.br +.br +.BI " nvme_admin_fabric_zoning_send" +, +.br +.br +.BI " nvme_admin_dbbuf" +, +.br +.br +.BI " nvme_admin_fabrics" +, +.br +.br +.BI " nvme_admin_format_nvm" +, +.br +.br +.BI " nvme_admin_security_send" +, +.br +.br +.BI " nvme_admin_security_recv" +, +.br +.br +.BI " nvme_admin_sanitize_nvm" +, +.br +.br +.BI " nvme_admin_get_lba_status" + +}; +.SH Constants +.IP "nvme_admin_delete_sq" 12 +Delete I/O Submission Queue +.IP "nvme_admin_create_sq" 12 +Create I/O Submission Queue +.IP "nvme_admin_get_log_page" 12 +Get Log Page +.IP "nvme_admin_delete_cq" 12 +Delete I/O Completion Queue +.IP "nvme_admin_create_cq" 12 +Create I/O Completion Queue +.IP "nvme_admin_identify" 12 +Identify +.IP "nvme_admin_abort_cmd" 12 +Abort +.IP "nvme_admin_set_features" 12 +Set Features +.IP "nvme_admin_get_features" 12 +Get Features +.IP "nvme_admin_async_event" 12 +Asynchronous Event Request +.IP "nvme_admin_ns_mgmt" 12 +Namespace Management +.IP "nvme_admin_fw_commit" 12 +Firmware Commit +.IP "nvme_admin_fw_activate" 12 +Firmware Commit +.IP "nvme_admin_fw_download" 12 +Firmware Image Download +.IP "nvme_admin_dev_self_test" 12 +Device Self-test +.IP "nvme_admin_ns_attach" 12 +Namespace Attachment +.IP "nvme_admin_keep_alive" 12 +Keep Alive +.IP "nvme_admin_directive_send" 12 +Directive Send +.IP "nvme_admin_directive_recv" 12 +Directive Receive +.IP "nvme_admin_virtual_mgmt" 12 +Virtualization Management +.IP "nvme_admin_nvme_mi_send" 12 +NVMe-MI Send +.IP "nvme_admin_nvme_mi_recv" 12 +NVMe-MI Receive +.IP "nvme_admin_capacity_mgmt" 12 +Capacity Management +.IP "nvme_admin_discovery_info_mgmt" 12 +Discovery Information Management (DIM) +.IP "nvme_admin_fabric_zoning_recv" 12 +Fabric Zoning Receive +.IP "nvme_admin_lockdown" 12 +Lockdown +.IP "nvme_admin_fabric_zoning_lookup" 12 +Fabric Zoning Lookup +.IP "nvme_admin_fabric_zoning_send" 12 +Fabric Zoning Send +.IP "nvme_admin_dbbuf" 12 +Doorbell Buffer Config +.IP "nvme_admin_fabrics" 12 +Fabrics Commands +.IP "nvme_admin_format_nvm" 12 +Format NVM +.IP "nvme_admin_security_send" 12 +Security Send +.IP "nvme_admin_security_recv" 12 +Security Receive +.IP "nvme_admin_sanitize_nvm" 12 +Sanitize +.IP "nvme_admin_get_lba_status" 12 +Get LBA Status diff --git a/doc/man/nvme_admin_passthru.2 b/doc/man/nvme_admin_passthru.2 new file mode 100644 index 0000000..df4dbf4 --- /dev/null +++ b/doc/man/nvme_admin_passthru.2 @@ -0,0 +1,71 @@ +.TH "nvme_admin_passthru" 9 "nvme_admin_passthru" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_admin_passthru \- Submit an nvme passthrough command +.SH SYNOPSIS +.B "int" nvme_admin_passthru +.BI "(int fd " "," +.BI "__u8 opcode " "," +.BI "__u8 flags " "," +.BI "__u16 rsvd " "," +.BI "__u32 nsid " "," +.BI "__u32 cdw2 " "," +.BI "__u32 cdw3 " "," +.BI "__u32 cdw10 " "," +.BI "__u32 cdw11 " "," +.BI "__u32 cdw12 " "," +.BI "__u32 cdw13 " "," +.BI "__u32 cdw14 " "," +.BI "__u32 cdw15 " "," +.BI "__u32 data_len " "," +.BI "void *data " "," +.BI "__u32 metadata_len " "," +.BI "void *metadata " "," +.BI "__u32 timeout_ms " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "opcode" 12 +The nvme io command to send +.IP "flags" 12 +NVMe command flags (not used) +.IP "rsvd" 12 +Reserevd for future use +.IP "nsid" 12 +Namespace identifier +.IP "cdw2" 12 +Command dword 2 +.IP "cdw3" 12 +Command dword 3 +.IP "cdw10" 12 +Command dword 10 +.IP "cdw11" 12 +Command dword 11 +.IP "cdw12" 12 +Command dword 12 +.IP "cdw13" 12 +Command dword 13 +.IP "cdw14" 12 +Command dword 14 +.IP "cdw15" 12 +Command dword 15 +.IP "data_len" 12 +Length of the data transfered in this command in bytes +.IP "data" 12 +Pointer to user address of the data buffer +.IP "metadata_len" 12 +Length of metadata transfered in this command +.IP "metadata" 12 +Pointer to user address of the metadata buffer +.IP "timeout_ms" 12 +How long the kernel waits for the command to complete +.IP "result" 12 +Optional field to return the result from the CQE dword 0 +.SH "DESCRIPTION" +Parameterized form of \fBnvme_submit_admin_passthru\fP. This sets up and +submits a \fIstruct nvme_passthru_cmd\fP. + +Known values for \fIopcode\fP are defined in \fIenum nvme_admin_opcode\fP. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_ae_info_css_nvm.2 b/doc/man/nvme_ae_info_css_nvm.2 new file mode 100644 index 0000000..b583463 --- /dev/null +++ b/doc/man/nvme_ae_info_css_nvm.2 @@ -0,0 +1,25 @@ +.TH "libnvme" 9 "enum nvme_ae_info_css_nvm" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_ae_info_css_nvm \- +.SH SYNOPSIS +enum nvme_ae_info_css_nvm { +.br +.BI " NVME_AER_CSS_NVM_RESERVATION" +, +.br +.br +.BI " NVME_AER_CSS_NVM_SANITIZE_COMPLETED" +, +.br +.br +.BI " NVME_AER_CSS_NVM_UNEXPECTED_SANITIZE_DEALLOC" + +}; +.SH Constants +.IP "NVME_AER_CSS_NVM_RESERVATION" 12 +Reservation Log Page Available +.IP "NVME_AER_CSS_NVM_SANITIZE_COMPLETED" 12 +Sanitize Operation Completed +.IP "NVME_AER_CSS_NVM_UNEXPECTED_SANITIZE_DEALLOC" 12 +Sanitize Operation Completed +With Unexpected Deallocation diff --git a/doc/man/nvme_ae_info_error.2 b/doc/man/nvme_ae_info_error.2 new file mode 100644 index 0000000..103b6a2 --- /dev/null +++ b/doc/man/nvme_ae_info_error.2 @@ -0,0 +1,42 @@ +.TH "libnvme" 9 "enum nvme_ae_info_error" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_ae_info_error \- +.SH SYNOPSIS +enum nvme_ae_info_error { +.br +.BI " NVME_AER_ERROR_INVALID_DB_REG" +, +.br +.br +.BI " NVME_AER_ERROR_INVALID_DB_VAL" +, +.br +.br +.BI " NVME_AER_ERROR_DIAG_FAILURE" +, +.br +.br +.BI " NVME_AER_ERROR_PERSISTENT_INTERNAL_ERROR" +, +.br +.br +.BI " NVME_AER_ERROR_TRANSIENT_INTERNAL_ERROR" +, +.br +.br +.BI " NVME_AER_ERROR_FW_IMAGE_LOAD_ERROR" + +}; +.SH Constants +.IP "NVME_AER_ERROR_INVALID_DB_REG" 12 +Write to Invalid Doorbell Register +.IP "NVME_AER_ERROR_INVALID_DB_VAL" 12 +Invalid Doorbell Write Value +.IP "NVME_AER_ERROR_DIAG_FAILURE" 12 +Diagnostic Failure +.IP "NVME_AER_ERROR_PERSISTENT_INTERNAL_ERROR" 12 +Persistent Internal Error +.IP "NVME_AER_ERROR_TRANSIENT_INTERNAL_ERROR" 12 +Transient Internal Error +.IP "NVME_AER_ERROR_FW_IMAGE_LOAD_ERROR" 12 +Firmware Image Load Error diff --git a/doc/man/nvme_ae_info_notice.2 b/doc/man/nvme_ae_info_notice.2 new file mode 100644 index 0000000..9c5ceb2 --- /dev/null +++ b/doc/man/nvme_ae_info_notice.2 @@ -0,0 +1,54 @@ +.TH "libnvme" 9 "enum nvme_ae_info_notice" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_ae_info_notice \- +.SH SYNOPSIS +enum nvme_ae_info_notice { +.br +.BI " NVME_AER_NOTICE_NS_CHANGED" +, +.br +.br +.BI " NVME_AER_NOTICE_FW_ACT_STARTING" +, +.br +.br +.BI " NVME_AER_NOTICE_TELEMETRY" +, +.br +.br +.BI " NVME_AER_NOTICE_ANA" +, +.br +.br +.BI " NVME_AER_NOTICE_PL_EVENT" +, +.br +.br +.BI " NVME_AER_NOTICE_LBA_STATUS_ALERT" +, +.br +.br +.BI " NVME_AER_NOTICE_EG_EVENT" +, +.br +.br +.BI " NVME_AER_NOTICE_DISC_CHANGED" + +}; +.SH Constants +.IP "NVME_AER_NOTICE_NS_CHANGED" 12 +Namespace Attribute Changed +.IP "NVME_AER_NOTICE_FW_ACT_STARTING" 12 +Firmware Activation Starting +.IP "NVME_AER_NOTICE_TELEMETRY" 12 +Telemetry Log Changed +.IP "NVME_AER_NOTICE_ANA" 12 +Asymmetric Namespace Access Change +.IP "NVME_AER_NOTICE_PL_EVENT" 12 +Predictable Latency Event Aggregate Log Change +.IP "NVME_AER_NOTICE_LBA_STATUS_ALERT" 12 +LBA Status Information Alert +.IP "NVME_AER_NOTICE_EG_EVENT" 12 +Endurance Group Event Aggregate Log Page Change +.IP "NVME_AER_NOTICE_DISC_CHANGED" 12 +Discovery Log Page Change diff --git a/doc/man/nvme_ae_info_smart.2 b/doc/man/nvme_ae_info_smart.2 new file mode 100644 index 0000000..1a6cd98 --- /dev/null +++ b/doc/man/nvme_ae_info_smart.2 @@ -0,0 +1,24 @@ +.TH "libnvme" 9 "enum nvme_ae_info_smart" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_ae_info_smart \- +.SH SYNOPSIS +enum nvme_ae_info_smart { +.br +.BI " NVME_AER_SMART_SUBSYSTEM_RELIABILITY" +, +.br +.br +.BI " NVME_AER_SMART_TEMPERATURE_THRESHOLD" +, +.br +.br +.BI " NVME_AER_SMART_SPARE_THRESHOLD" + +}; +.SH Constants +.IP "NVME_AER_SMART_SUBSYSTEM_RELIABILITY" 12 +NVM subsystem Reliability +.IP "NVME_AER_SMART_TEMPERATURE_THRESHOLD" 12 +Temperature Threshold +.IP "NVME_AER_SMART_SPARE_THRESHOLD" 12 +Spare Below Threshold diff --git a/doc/man/nvme_ae_type.2 b/doc/man/nvme_ae_type.2 new file mode 100644 index 0000000..514ea84 --- /dev/null +++ b/doc/man/nvme_ae_type.2 @@ -0,0 +1,36 @@ +.TH "libnvme" 9 "enum nvme_ae_type" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_ae_type \- +.SH SYNOPSIS +enum nvme_ae_type { +.br +.BI " NVME_AER_ERROR" +, +.br +.br +.BI " NVME_AER_SMART" +, +.br +.br +.BI " NVME_AER_NOTICE" +, +.br +.br +.BI " NVME_AER_CSS" +, +.br +.br +.BI " NVME_AER_VS" + +}; +.SH Constants +.IP "NVME_AER_ERROR" 12 +Error event +.IP "NVME_AER_SMART" 12 +SMART / Health Status event +.IP "NVME_AER_NOTICE" 12 +Notice event +.IP "NVME_AER_CSS" 12 +NVM Command Set Specific events +.IP "NVME_AER_VS" 12 +Vendor Specific event diff --git a/doc/man/nvme_aggregate_endurance_group_event.2 b/doc/man/nvme_aggregate_endurance_group_event.2 new file mode 100644 index 0000000..c7656cd --- /dev/null +++ b/doc/man/nvme_aggregate_endurance_group_event.2 @@ -0,0 +1,19 @@ +.TH "libnvme" 9 "struct nvme_aggregate_endurance_group_event" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_aggregate_endurance_group_event \- +.SH SYNOPSIS +struct nvme_aggregate_endurance_group_event { +.br +.BI " __le64 num_entries;" +.br +.BI " __le16 entries[];" +.br +.BI " +}; +.br + +.SH Members +.IP "num_entries" 12 +Number or entries +.IP "entries" 12 +List of entries diff --git a/doc/man/nvme_aggregate_predictable_lat_event.2 b/doc/man/nvme_aggregate_predictable_lat_event.2 new file mode 100644 index 0000000..26937e2 --- /dev/null +++ b/doc/man/nvme_aggregate_predictable_lat_event.2 @@ -0,0 +1,19 @@ +.TH "libnvme" 9 "struct nvme_aggregate_predictable_lat_event" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_aggregate_predictable_lat_event \- +.SH SYNOPSIS +struct nvme_aggregate_predictable_lat_event { +.br +.BI " __le64 num_entries;" +.br +.BI " __le16 entries[];" +.br +.BI " +}; +.br + +.SH Members +.IP "num_entries" 12 +Number of entries +.IP "entries" 12 +Entry list diff --git a/doc/man/nvme_ana_group_desc.2 b/doc/man/nvme_ana_group_desc.2 new file mode 100644 index 0000000..5b8ceb9 --- /dev/null +++ b/doc/man/nvme_ana_group_desc.2 @@ -0,0 +1,35 @@ +.TH "libnvme" 9 "struct nvme_ana_group_desc" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_ana_group_desc \- +.SH SYNOPSIS +struct nvme_ana_group_desc { +.br +.BI " __le32 grpid;" +.br +.BI " __le32 nnsids;" +.br +.BI " __le64 chgcnt;" +.br +.BI " __u8 state;" +.br +.BI " __u8 rsvd17[15];" +.br +.BI " __le32 nsids[];" +.br +.BI " +}; +.br + +.SH Members +.IP "grpid" 12 +ANA group id +.IP "nnsids" 12 +Number of namespaces in \fInsids\fP +.IP "chgcnt" 12 +Change counter +.IP "state" 12 +ANA state +.IP "rsvd17" 12 +Reserved +.IP "nsids" 12 +List of namespaces diff --git a/doc/man/nvme_ana_log.2 b/doc/man/nvme_ana_log.2 new file mode 100644 index 0000000..51b4bd8 --- /dev/null +++ b/doc/man/nvme_ana_log.2 @@ -0,0 +1,27 @@ +.TH "libnvme" 9 "struct nvme_ana_log" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_ana_log \- +.SH SYNOPSIS +struct nvme_ana_log { +.br +.BI " __le64 chgcnt;" +.br +.BI " __le16 ngrps;" +.br +.BI " __u8 rsvd10[6];" +.br +.BI " struct nvme_ana_group_desc descs[];" +.br +.BI " +}; +.br + +.SH Members +.IP "chgcnt" 12 +Change Count +.IP "ngrps" 12 +Number of ANA Group Descriptors +.IP "rsvd10" 12 +Reserved +.IP "descs" 12 +ANA Group Descriptor diff --git a/doc/man/nvme_ana_state.2 b/doc/man/nvme_ana_state.2 new file mode 100644 index 0000000..83d50b6 --- /dev/null +++ b/doc/man/nvme_ana_state.2 @@ -0,0 +1,31 @@ +.TH "libnvme" 9 "enum nvme_ana_state" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_ana_state \- +.SH SYNOPSIS +enum nvme_ana_state { +.br +.BI " NVME_ANA_STATE_OPTIMIZED" +, +.br +.br +.BI " NVME_ANA_STATE_NONOPTIMIZED" +, +.br +.br +.BI " NVME_ANA_STATE_INACCESSIBLE" +, +.br +.br +.BI " NVME_ANA_STATE_PERSISTENT_LOSS" +, +.br +.br +.BI " NVME_ANA_STATE_CHANGE" + +}; +.SH Constants +.IP "NVME_ANA_STATE_OPTIMIZED" 12 +.IP "NVME_ANA_STATE_NONOPTIMIZED" 12 +.IP "NVME_ANA_STATE_INACCESSIBLE" 12 +.IP "NVME_ANA_STATE_PERSISTENT_LOSS" 12 +.IP "NVME_ANA_STATE_CHANGE" 12 diff --git a/doc/man/nvme_apst_entry.2 b/doc/man/nvme_apst_entry.2 new file mode 100644 index 0000000..fb52310 --- /dev/null +++ b/doc/man/nvme_apst_entry.2 @@ -0,0 +1,26 @@ +.TH "libnvme" 9 "enum nvme_apst_entry" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_apst_entry \- +.SH SYNOPSIS +enum nvme_apst_entry { +.br +.BI " NVME_APST_ENTRY_ITPS_SHIFT" +, +.br +.br +.BI " NVME_APST_ENTRY_ITPT_SHIFT" +, +.br +.br +.BI " NVME_APST_ENTRY_ITPS_MASK" +, +.br +.br +.BI " NVME_APST_ENTRY_ITPT_MASK" + +}; +.SH Constants +.IP "NVME_APST_ENTRY_ITPS_SHIFT" 12 +.IP "NVME_APST_ENTRY_ITPT_SHIFT" 12 +.IP "NVME_APST_ENTRY_ITPS_MASK" 12 +.IP "NVME_APST_ENTRY_ITPT_MASK" 12 diff --git a/doc/man/nvme_boot_partition.2 b/doc/man/nvme_boot_partition.2 new file mode 100644 index 0000000..3403da5 --- /dev/null +++ b/doc/man/nvme_boot_partition.2 @@ -0,0 +1,32 @@ +.TH "libnvme" 9 "struct nvme_boot_partition" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_boot_partition \- +.SH SYNOPSIS +struct nvme_boot_partition { +.br +.BI " __u8 lid;" +.br +.BI " __u8 rsvd1[3];" +.br +.BI " __le32 bpinfo;" +.br +.BI " __u8 rsvd8[8];" +.br +.BI " __u8 boot_partition_data[];" +.br +.BI " +}; +.br + +.SH Members +.IP "lid" 12 +Boot Partition Identifier +.IP "rsvd1" 12 +Reserved +.IP "bpinfo" 12 +Boot Partition Information +.IP "rsvd8" 12 +Reserved +.IP "boot_partition_data" 12 +Contains the contents of the +specified Boot Partition diff --git a/doc/man/nvme_cap_config_desc.2 b/doc/man/nvme_cap_config_desc.2 new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/doc/man/nvme_cap_config_desc.2 diff --git a/doc/man/nvme_capacity_mgmt.2 b/doc/man/nvme_capacity_mgmt.2 new file mode 100644 index 0000000..4ebf6a2 --- /dev/null +++ b/doc/man/nvme_capacity_mgmt.2 @@ -0,0 +1,12 @@ +.TH "nvme_capacity_mgmt" 9 "nvme_capacity_mgmt" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_capacity_mgmt \- +.SH SYNOPSIS +.B "int" nvme_capacity_mgmt +.BI "(struct nvme_capacity_mgmt_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_capacity_mgmt_args\fP argument structure +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_capacity_mgmt_args.2 b/doc/man/nvme_capacity_mgmt_args.2 new file mode 100644 index 0000000..b3c42e7 --- /dev/null +++ b/doc/man/nvme_capacity_mgmt_args.2 @@ -0,0 +1,45 @@ +.TH "libnvme" 9 "struct nvme_capacity_mgmt_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_capacity_mgmt_args \- Arguments for the NVMe Capacity Management command +.SH SYNOPSIS +struct nvme_capacity_mgmt_args { +.br +.BI " __u32 *result;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u32 cdw11;" +.br +.BI " __u32 cdw12;" +.br +.BI " __u16 element_id;" +.br +.BI " __u8 op;" +.br +.BI " +}; +.br + +.SH Members +.IP "result" 12 +If successful, the CQE dword0 value +.IP "args_size" 12 +Size of \fIstruct nvme_capacity_mgmt_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "cdw11" 12 +Least significant 32 bits of the capacity in bytes of the +Endurance Group or NVM Set to be created +.IP "cdw12" 12 +Most significant 32 bits of the capacity in bytes of the +Endurance Group or NVM Set to be created +.IP "element_id" 12 +Value specific to the value of the Operation field +.IP "op" 12 +Operation to be performed by the controller diff --git a/doc/man/nvme_change_ns_event.2 b/doc/man/nvme_change_ns_event.2 new file mode 100644 index 0000000..e7d329c --- /dev/null +++ b/doc/man/nvme_change_ns_event.2 @@ -0,0 +1,63 @@ +.TH "libnvme" 9 "struct nvme_change_ns_event" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_change_ns_event \- +.SH SYNOPSIS +struct nvme_change_ns_event { +.br +.BI " __le32 nsmgt_cdw10;" +.br +.BI " __u8 rsvd4[4];" +.br +.BI " __le64 nsze;" +.br +.BI " __u8 rsvd16[8];" +.br +.BI " __le64 nscap;" +.br +.BI " __u8 flbas;" +.br +.BI " __u8 dps;" +.br +.BI " __u8 nmic;" +.br +.BI " __u8 rsvd35;" +.br +.BI " __le32 ana_grp_id;" +.br +.BI " __le16 nvmset_id;" +.br +.BI " __le16 rsvd42;" +.br +.BI " __le32 nsid;" +.br +.BI " +}; +.br + +.SH Members +.IP "nsmgt_cdw10" 12 +Namespace Management CDW10 +.IP "rsvd4" 12 +Reserved +.IP "nsze" 12 +Namespace Size +.IP "rsvd16" 12 +Reserved +.IP "nscap" 12 +Namespace Capacity +.IP "flbas" 12 +Formatted LBA Size +.IP "dps" 12 +End-to-end Data Protection Type Settings +.IP "nmic" 12 +Namespace Multi-path I/O and Namespace Sharing Capabilities +.IP "rsvd35" 12 +Reserved +.IP "ana_grp_id" 12 +ANA Group Identifier +.IP "nvmset_id" 12 +NVM Set Identifier +.IP "rsvd42" 12 +Reserved +.IP "nsid" 12 +Namespace ID diff --git a/doc/man/nvme_channel_config_desc.2 b/doc/man/nvme_channel_config_desc.2 new file mode 100644 index 0000000..844f858 --- /dev/null +++ b/doc/man/nvme_channel_config_desc.2 @@ -0,0 +1,24 @@ +.TH "libnvme" 9 "struct nvme_channel_config_desc" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_channel_config_desc \- +.SH SYNOPSIS +struct nvme_channel_config_desc { +.br +.BI " __le16 chanid;" +.br +.BI " __le16 chmus;" +.br +.BI " struct nvme_media_unit_config_desc mu_config_desc[];" +.br +.BI " +}; +.br + +.SH Members +.IP "chanid" 12 +Channel Identifier +.IP "chmus" 12 +Number Channel Media Units +.SH "Description" +Channel Configuration Descriptor +Structure Definitions diff --git a/doc/man/nvme_cmb_size.2 b/doc/man/nvme_cmb_size.2 new file mode 100644 index 0000000..395347d --- /dev/null +++ b/doc/man/nvme_cmb_size.2 @@ -0,0 +1,11 @@ +.TH "nvme_cmb_size" 9 "nvme_cmb_size" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_cmb_size \- Calculate size of the controller memory buffer +.SH SYNOPSIS +.B "__u64" nvme_cmb_size +.BI "(__u32 cmbsz " ");" +.SH ARGUMENTS +.IP "cmbsz" 12 +Value from controller register NVME_REG_CMBSZ +.SH "DESCRIPTION" +Returns size of controller memory buffer in bytes diff --git a/doc/man/nvme_cmd_effects.2 b/doc/man/nvme_cmd_effects.2 new file mode 100644 index 0000000..f0cf27b --- /dev/null +++ b/doc/man/nvme_cmd_effects.2 @@ -0,0 +1,48 @@ +.TH "libnvme" 9 "enum nvme_cmd_effects" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_cmd_effects \- +.SH SYNOPSIS +enum nvme_cmd_effects { +.br +.BI " NVME_CMD_EFFECTS_CSUPP" +, +.br +.br +.BI " NVME_CMD_EFFECTS_LBCC" +, +.br +.br +.BI " NVME_CMD_EFFECTS_NCC" +, +.br +.br +.BI " NVME_CMD_EFFECTS_NIC" +, +.br +.br +.BI " NVME_CMD_EFFECTS_CCC" +, +.br +.br +.BI " NVME_CMD_EFFECTS_CSE_MASK" +, +.br +.br +.BI " NVME_CMD_EFFECTS_UUID_SEL" + +}; +.SH Constants +.IP "NVME_CMD_EFFECTS_CSUPP" 12 +Command Supported +.IP "NVME_CMD_EFFECTS_LBCC" 12 +Logical Block Content Change +.IP "NVME_CMD_EFFECTS_NCC" 12 +Namespace Capability Change +.IP "NVME_CMD_EFFECTS_NIC" 12 +Namespace Inventory Change +.IP "NVME_CMD_EFFECTS_CCC" 12 +Controller Capability Change +.IP "NVME_CMD_EFFECTS_CSE_MASK" 12 +Command Submission and Execution +.IP "NVME_CMD_EFFECTS_UUID_SEL" 12 +UUID Selection Supported diff --git a/doc/man/nvme_cmd_effects_log.2 b/doc/man/nvme_cmd_effects_log.2 new file mode 100644 index 0000000..7458732 --- /dev/null +++ b/doc/man/nvme_cmd_effects_log.2 @@ -0,0 +1,23 @@ +.TH "libnvme" 9 "struct nvme_cmd_effects_log" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_cmd_effects_log \- +.SH SYNOPSIS +struct nvme_cmd_effects_log { +.br +.BI " __le32 acs[256];" +.br +.BI " __le32 iocs[256];" +.br +.BI " __u8 rsvd[2048];" +.br +.BI " +}; +.br + +.SH Members +.IP "acs" 12 +Admin Command Supported +.IP "iocs" 12 +I/O Command Supported +.IP "rsvd" 12 +Reserved diff --git a/doc/man/nvme_cmd_format_mset.2 b/doc/man/nvme_cmd_format_mset.2 new file mode 100644 index 0000000..dba60cd --- /dev/null +++ b/doc/man/nvme_cmd_format_mset.2 @@ -0,0 +1,20 @@ +.TH "libnvme" 9 "enum nvme_cmd_format_mset" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_cmd_format_mset \- Format NVM - Metadata Settings +.SH SYNOPSIS +enum nvme_cmd_format_mset { +.br +.BI " NVME_FORMAT_MSET_SEPARATE" +, +.br +.br +.BI " NVME_FORMAT_MSET_EXTENDED" + +}; +.SH Constants +.IP "NVME_FORMAT_MSET_SEPARATE" 12 +indicates that the metadata is transferred +as part of a separate buffer. +.IP "NVME_FORMAT_MSET_EXTENDED" 12 +indicates that the metadata is transferred +as part of an extended data LBA. diff --git a/doc/man/nvme_cmd_format_pi.2 b/doc/man/nvme_cmd_format_pi.2 new file mode 100644 index 0000000..4388656 --- /dev/null +++ b/doc/man/nvme_cmd_format_pi.2 @@ -0,0 +1,30 @@ +.TH "libnvme" 9 "enum nvme_cmd_format_pi" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_cmd_format_pi \- Format NVM - Protection Information +.SH SYNOPSIS +enum nvme_cmd_format_pi { +.br +.BI " NVME_FORMAT_PI_DISABLE" +, +.br +.br +.BI " NVME_FORMAT_PI_TYPE1" +, +.br +.br +.BI " NVME_FORMAT_PI_TYPE2" +, +.br +.br +.BI " NVME_FORMAT_PI_TYPE3" + +}; +.SH Constants +.IP "NVME_FORMAT_PI_DISABLE" 12 +Protection information is not enabled. +.IP "NVME_FORMAT_PI_TYPE1" 12 +Protection information is enabled, Type 1. +.IP "NVME_FORMAT_PI_TYPE2" 12 +Protection information is enabled, Type 2. +.IP "NVME_FORMAT_PI_TYPE3" 12 +Protection information is enabled, Type 3. diff --git a/doc/man/nvme_cmd_format_pil.2 b/doc/man/nvme_cmd_format_pil.2 new file mode 100644 index 0000000..a0b3269 --- /dev/null +++ b/doc/man/nvme_cmd_format_pil.2 @@ -0,0 +1,20 @@ +.TH "libnvme" 9 "enum nvme_cmd_format_pil" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_cmd_format_pil \- Format NVM - Protection Information Location +.SH SYNOPSIS +enum nvme_cmd_format_pil { +.br +.BI " NVME_FORMAT_PIL_LAST" +, +.br +.br +.BI " NVME_FORMAT_PIL_FIRST" + +}; +.SH Constants +.IP "NVME_FORMAT_PIL_LAST" 12 +Protection information is transferred as the last +bytes of metadata. +.IP "NVME_FORMAT_PIL_FIRST" 12 +Protection information is transferred as the first +bytes of metadata. diff --git a/doc/man/nvme_cmd_format_ses.2 b/doc/man/nvme_cmd_format_ses.2 new file mode 100644 index 0000000..d2b6ed5 --- /dev/null +++ b/doc/man/nvme_cmd_format_ses.2 @@ -0,0 +1,33 @@ +.TH "libnvme" 9 "enum nvme_cmd_format_ses" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_cmd_format_ses \- Format NVM - Secure Erase Settings +.SH SYNOPSIS +enum nvme_cmd_format_ses { +.br +.BI " NVME_FORMAT_SES_NONE" +, +.br +.br +.BI " NVME_FORMAT_SES_USER_DATA_ERASE" +, +.br +.br +.BI " NVME_FORMAT_SES_CRYPTO_ERASE" + +}; +.SH Constants +.IP "NVME_FORMAT_SES_NONE" 12 +No secure erase operation requested. +.IP "NVME_FORMAT_SES_USER_DATA_ERASE" 12 +User Data Erase: All user data shall be erased, +contents of the user data after the erase is +indeterminate (e.g. the user data may be zero +filled, one filled, etc.). If a User Data Erase +is requested and all affected user data is +encrypted, then the controller is allowed +to use a cryptographic erase to perform +the requested User Data Erase. +.IP "NVME_FORMAT_SES_CRYPTO_ERASE" 12 +Cryptographic Erase: All user data shall +be erased cryptographically. This is +accomplished by deleting the encryption key. diff --git a/doc/man/nvme_cmd_get_log_lid.2 b/doc/man/nvme_cmd_get_log_lid.2 new file mode 100644 index 0000000..f2023ad --- /dev/null +++ b/doc/man/nvme_cmd_get_log_lid.2 @@ -0,0 +1,156 @@ +.TH "libnvme" 9 "enum nvme_cmd_get_log_lid" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_cmd_get_log_lid \- +.SH SYNOPSIS +enum nvme_cmd_get_log_lid { +.br +.BI " NVME_LOG_LID_SUPPORTED_LOG_PAGES" +, +.br +.br +.BI " NVME_LOG_LID_ERROR" +, +.br +.br +.BI " NVME_LOG_LID_SMART" +, +.br +.br +.BI " NVME_LOG_LID_FW_SLOT" +, +.br +.br +.BI " NVME_LOG_LID_CHANGED_NS" +, +.br +.br +.BI " NVME_LOG_LID_CMD_EFFECTS" +, +.br +.br +.BI " NVME_LOG_LID_DEVICE_SELF_TEST" +, +.br +.br +.BI " NVME_LOG_LID_TELEMETRY_HOST" +, +.br +.br +.BI " NVME_LOG_LID_TELEMETRY_CTRL" +, +.br +.br +.BI " NVME_LOG_LID_ENDURANCE_GROUP" +, +.br +.br +.BI " NVME_LOG_LID_PREDICTABLE_LAT_NVMSET" +, +.br +.br +.BI " NVME_LOG_LID_PREDICTABLE_LAT_AGG" +, +.br +.br +.BI " NVME_LOG_LID_ANA" +, +.br +.br +.BI " NVME_LOG_LID_PERSISTENT_EVENT" +, +.br +.br +.BI " NVME_LOG_LID_LBA_STATUS" +, +.br +.br +.BI " NVME_LOG_LID_ENDURANCE_GRP_EVT" +, +.br +.br +.BI " NVME_LOG_LID_MEDIA_UNIT_STATUS" +, +.br +.br +.BI " NVME_LOG_LID_SUPPORTED_CAP_CONFIG_LIST" +, +.br +.br +.BI " NVME_LOG_LID_FID_SUPPORTED_EFFECTS" +, +.br +.br +.BI " NVME_LOG_LID_MI_CMD_SUPPORTED_EFFECTS" +, +.br +.br +.BI " NVME_LOG_LID_BOOT_PARTITION" +, +.br +.br +.BI " NVME_LOG_LID_DISCOVER" +, +.br +.br +.BI " NVME_LOG_LID_RESERVATION" +, +.br +.br +.BI " NVME_LOG_LID_SANITIZE" +, +.br +.br +.BI " NVME_LOG_LID_ZNS_CHANGED_ZONES" + +}; +.SH Constants +.IP "NVME_LOG_LID_SUPPORTED_LOG_PAGES" 12 +Supported Log Pages +.IP "NVME_LOG_LID_ERROR" 12 +Error Information +.IP "NVME_LOG_LID_SMART" 12 +SMART / Health Information +.IP "NVME_LOG_LID_FW_SLOT" 12 +Firmware Slot Information +.IP "NVME_LOG_LID_CHANGED_NS" 12 +Changed Namespace List +.IP "NVME_LOG_LID_CMD_EFFECTS" 12 +Commands Supported and Effects +.IP "NVME_LOG_LID_DEVICE_SELF_TEST" 12 +Device Self-test +.IP "NVME_LOG_LID_TELEMETRY_HOST" 12 +Telemetry Host-Initiated +.IP "NVME_LOG_LID_TELEMETRY_CTRL" 12 +Telemetry Controller-Initiated +.IP "NVME_LOG_LID_ENDURANCE_GROUP" 12 +Endurance Group Information +.IP "NVME_LOG_LID_PREDICTABLE_LAT_NVMSET" 12 +Predictable Latency Per NVM Set +.IP "NVME_LOG_LID_PREDICTABLE_LAT_AGG" 12 +Predictable Latency Event Aggregate +.IP "NVME_LOG_LID_ANA" 12 +Asymmetric Namespace Access +.IP "NVME_LOG_LID_PERSISTENT_EVENT" 12 +Persistent Event Log +.IP "NVME_LOG_LID_LBA_STATUS" 12 +LBA Status Information +.IP "NVME_LOG_LID_ENDURANCE_GRP_EVT" 12 +Endurance Group Event Aggregate +.IP "NVME_LOG_LID_MEDIA_UNIT_STATUS" 12 +Media Unit Status +.IP "NVME_LOG_LID_SUPPORTED_CAP_CONFIG_LIST" 12 +Supported Capacity Configuration Lis +.IP "NVME_LOG_LID_FID_SUPPORTED_EFFECTS" 12 +Feature Identifiers Supported and Effects +.IP "NVME_LOG_LID_MI_CMD_SUPPORTED_EFFECTS" 12 +NVMe-MI Commands Supported and Effects +.IP "NVME_LOG_LID_BOOT_PARTITION" 12 +Boot Partition +.IP "NVME_LOG_LID_DISCOVER" 12 +Discovery +.IP "NVME_LOG_LID_RESERVATION" 12 +Reservation Notification +.IP "NVME_LOG_LID_SANITIZE" 12 +Sanitize Status +.IP "NVME_LOG_LID_ZNS_CHANGED_ZONES" 12 +Changed Zone List diff --git a/doc/man/nvme_cmd_get_log_telemetry_host_lsp.2 b/doc/man/nvme_cmd_get_log_telemetry_host_lsp.2 new file mode 100644 index 0000000..062093a --- /dev/null +++ b/doc/man/nvme_cmd_get_log_telemetry_host_lsp.2 @@ -0,0 +1,16 @@ +.TH "libnvme" 9 "enum nvme_cmd_get_log_telemetry_host_lsp" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_cmd_get_log_telemetry_host_lsp \- +.SH SYNOPSIS +enum nvme_cmd_get_log_telemetry_host_lsp { +.br +.BI " NVME_LOG_TELEM_HOST_LSP_RETAIN" +, +.br +.br +.BI " NVME_LOG_TELEM_HOST_LSP_CREATE" + +}; +.SH Constants +.IP "NVME_LOG_TELEM_HOST_LSP_RETAIN" 12 +.IP "NVME_LOG_TELEM_HOST_LSP_CREATE" 12 diff --git a/doc/man/nvme_compare.2 b/doc/man/nvme_compare.2 new file mode 100644 index 0000000..5a3214b --- /dev/null +++ b/doc/man/nvme_compare.2 @@ -0,0 +1,12 @@ +.TH "nvme_compare" 9 "nvme_compare" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_compare \- Submit an nvme user compare command +.SH SYNOPSIS +.B "int" nvme_compare +.BI "(struct nvme_io_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_io_args\fP argument structure +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_connect_err.2 b/doc/man/nvme_connect_err.2 new file mode 100644 index 0000000..821fa74 --- /dev/null +++ b/doc/man/nvme_connect_err.2 @@ -0,0 +1,78 @@ +.TH "libnvme" 9 "enum nvme_connect_err" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_connect_err \- nvme connect error codes +.SH SYNOPSIS +enum nvme_connect_err { +.br +.BI " ENVME_CONNECT_RESOLVE" +, +.br +.br +.BI " ENVME_CONNECT_ADDRFAM" +, +.br +.br +.BI " ENVME_CONNECT_TRADDR" +, +.br +.br +.BI " ENVME_CONNECT_TARG" +, +.br +.br +.BI " ENVME_CONNECT_AARG" +, +.br +.br +.BI " ENVME_CONNECT_OPEN" +, +.br +.br +.BI " ENVME_CONNECT_WRITE" +, +.br +.br +.BI " ENVME_CONNECT_READ" +, +.br +.br +.BI " ENVME_CONNECT_PARSE" +, +.br +.br +.BI " ENVME_CONNECT_INVAL_TR" +, +.br +.br +.BI " ENVME_CONNECT_LOOKUP_SUBSYS_NAME" +, +.br +.br +.BI " ENVME_CONNECT_LOOKUP_SUBSYS" + +}; +.SH Constants +.IP "ENVME_CONNECT_RESOLVE" 12 +failed to resolve host +.IP "ENVME_CONNECT_ADDRFAM" 12 +unrecognized address family +.IP "ENVME_CONNECT_TRADDR" 12 +failed to get traddr +.IP "ENVME_CONNECT_TARG" 12 +need a transport (-t) argument +.IP "ENVME_CONNECT_AARG" 12 +need a address (-a) argument +.IP "ENVME_CONNECT_OPEN" 12 +failed to open nvme-fabrics device +.IP "ENVME_CONNECT_WRITE" 12 +failed to write to nvme-fabrics device +.IP "ENVME_CONNECT_READ" 12 +failed to read from nvme-fabrics device +.IP "ENVME_CONNECT_PARSE" 12 +failed to parse ctrl info +.IP "ENVME_CONNECT_INVAL_TR" 12 +invalid transport type +.IP "ENVME_CONNECT_LOOKUP_SUBSYS_NAME" 12 +failed to lookup subsystem name +.IP "ENVME_CONNECT_LOOKUP_SUBSYS" 12 +failed to lookup subsystem diff --git a/doc/man/nvme_constants.2 b/doc/man/nvme_constants.2 new file mode 100644 index 0000000..ab07e99 --- /dev/null +++ b/doc/man/nvme_constants.2 @@ -0,0 +1,199 @@ +.TH "libnvme" 9 "enum nvme_constants" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_constants \- A place to stash various constant nvme values +.SH SYNOPSIS +enum nvme_constants { +.br +.BI " NVME_NSID_ALL" +, +.br +.br +.BI " NVME_NSID_NONE" +, +.br +.br +.BI " NVME_UUID_NONE" +, +.br +.br +.BI " NVME_CNTLID_NONE" +, +.br +.br +.BI " NVME_CNSSPECID_NONE" +, +.br +.br +.BI " NVME_LOG_LSP_NONE" +, +.br +.br +.BI " NVME_LOG_LSI_NONE" +, +.br +.br +.BI " NVME_LOG_LPO_NONE" +, +.br +.br +.BI " NVME_IDENTIFY_DATA_SIZE" +, +.br +.br +.BI " NVME_LOG_SUPPORTED_LOG_PAGES_MAX" +, +.br +.br +.BI " NVME_ID_NVMSET_LIST_MAX" +, +.br +.br +.BI " NVME_ID_UUID_LIST_MAX" +, +.br +.br +.BI " NVME_ID_CTRL_LIST_MAX" +, +.br +.br +.BI " NVME_ID_NS_LIST_MAX" +, +.br +.br +.BI " NVME_ID_SECONDARY_CTRL_MAX" +, +.br +.br +.BI " NVME_ID_DOMAIN_LIST_MAX" +, +.br +.br +.BI " NVME_ID_ENDURANCE_GROUP_LIST_MAX" +, +.br +.br +.BI " NVME_ID_ND_DESCRIPTOR_MAX" +, +.br +.br +.BI " NVME_FEAT_LBA_RANGE_MAX" +, +.br +.br +.BI " NVME_LOG_ST_MAX_RESULTS" +, +.br +.br +.BI " NVME_LOG_TELEM_BLOCK_SIZE" +, +.br +.br +.BI " NVME_LOG_FID_SUPPORTED_EFFECTS_MAX" +, +.br +.br +.BI " NVME_LOG_MI_CMD_SUPPORTED_EFFECTS_MAX" +, +.br +.br +.BI " NVME_LOG_MI_CMD_SUPPORTED_EFFECTS_RESERVED" +, +.br +.br +.BI " NVME_DSM_MAX_RANGES" +, +.br +.br +.BI " NVME_NQN_LENGTH" +, +.br +.br +.BI " NVMF_TRADDR_SIZE" +, +.br +.br +.BI " NVMF_TSAS_SIZE" +, +.br +.br +.BI " NVME_ZNS_CHANGED_ZONES_MAX" + +}; +.SH Constants +.IP "NVME_NSID_ALL" 12 +A broadcast value that is used to specify all +namespaces +.IP "NVME_NSID_NONE" 12 +The invalid namespace id, for when the nsid +parameter is not used in a command +.IP "NVME_UUID_NONE" 12 +Use to omit a uuid command parameter +.IP "NVME_CNTLID_NONE" 12 +Use to omit a cntlid command parameter +.IP "NVME_CNSSPECID_NONE" 12 +Use to omit a cns_specific_id command parameter +.IP "NVME_LOG_LSP_NONE" 12 +Use to omit a log lsp command parameter +.IP "NVME_LOG_LSI_NONE" 12 +Use to omit a log lsi command parameter +.IP "NVME_LOG_LPO_NONE" 12 +Use to omit a log lpo command parameter +.IP "NVME_IDENTIFY_DATA_SIZE" 12 +The transfer size for nvme identify commands +.IP "NVME_LOG_SUPPORTED_LOG_PAGES_MAX" 12 +The lagest possible index in the supported +log pages log. +.IP "NVME_ID_NVMSET_LIST_MAX" 12 +The largest possible nvmset index in identify +nvmeset +.IP "NVME_ID_UUID_LIST_MAX" 12 +The largest possible uuid index in identify +uuid list +.IP "NVME_ID_CTRL_LIST_MAX" 12 +The largest possible controller index in +identify controller list +.IP "NVME_ID_NS_LIST_MAX" 12 +The largest possible namespace index in +identify namespace list +.IP "NVME_ID_SECONDARY_CTRL_MAX" 12 +The largest possible secondary controller index +in identify secondary controller +.IP "NVME_ID_DOMAIN_LIST_MAX" 12 +The largest possible domain index in the +in domain list +.IP "NVME_ID_ENDURANCE_GROUP_LIST_MAX" 12 +The largest possible endurance group +index in the endurance group list +.IP "NVME_ID_ND_DESCRIPTOR_MAX" 12 +The largest possible namespace granularity +index in the namespace granularity descriptor +list +.IP "NVME_FEAT_LBA_RANGE_MAX" 12 +The largest possible LBA range index in feature +lba range type +.IP "NVME_LOG_ST_MAX_RESULTS" 12 +The largest possible self test result index in the +device self test log +.IP "NVME_LOG_TELEM_BLOCK_SIZE" 12 +Specification defined size of Telemetry Data Blocks +.IP "NVME_LOG_FID_SUPPORTED_EFFECTS_MAX" 12 +The largest possible FID index in the +feature identifiers effects log. +.IP "NVME_LOG_MI_CMD_SUPPORTED_EFFECTS_MAX" 12 +The largest possible MI Command index +in the MI Command effects log. +.IP "NVME_LOG_MI_CMD_SUPPORTED_EFFECTS_RESERVED" 12 +The reserved space in the MI Command +effects log. +.IP "NVME_DSM_MAX_RANGES" 12 +The largest possible range index in a data-set +management command +.IP "NVME_NQN_LENGTH" 12 +Max length for NVMe Qualified Name +.IP "NVMF_TRADDR_SIZE" 12 +Max Transport Address size +.IP "NVMF_TSAS_SIZE" 12 +Max Transport Specific Address Subtype size +.IP "NVME_ZNS_CHANGED_ZONES_MAX" 12 +Max number of zones in the changed zones log +page diff --git a/doc/man/nvme_copy.2 b/doc/man/nvme_copy.2 new file mode 100644 index 0000000..c8cdf33 --- /dev/null +++ b/doc/man/nvme_copy.2 @@ -0,0 +1,12 @@ +.TH "nvme_copy" 9 "nvme_copy" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_copy \- +.SH SYNOPSIS +.B "int" nvme_copy +.BI "(struct nvme_copy_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_copy_args\fP argument structure +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_copy_args.2 b/doc/man/nvme_copy_args.2 new file mode 100644 index 0000000..5cc2fe1 --- /dev/null +++ b/doc/man/nvme_copy_args.2 @@ -0,0 +1,83 @@ +.TH "libnvme" 9 "struct nvme_copy_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_copy_args \- Arguments for the NVMe Copy command +.SH SYNOPSIS +struct nvme_copy_args { +.br +.BI " __u64 sdlba;" +.br +.BI " __u32 *result;" +.br +.BI " struct nvme_copy_range *copy;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u32 nsid;" +.br +.BI " __u32 ilbrt;" +.br +.BI " int lr;" +.br +.BI " int fua;" +.br +.BI " __u16 nr;" +.br +.BI " __u16 dspec;" +.br +.BI " __u16 lbatm;" +.br +.BI " __u16 lbat;" +.br +.BI " __u8 prinfor;" +.br +.BI " __u8 prinfow;" +.br +.BI " __u8 dtype;" +.br +.BI " __u8 format;" +.br +.BI " +}; +.br + +.SH Members +.IP "sdlba" 12 +Start destination LBA +.IP "result" 12 +The command completion result from CQE dword0 +.IP "copy" 12 +Range descriptior +.IP "args_size" 12 +Size of \fIstruct nvme_copy_args\fP +.IP "fd" 12 +File descriptor of the nvme device +.IP "timeout" 12 +Timeout in ms +.IP "nsid" 12 +Namespace identifier +.IP "ilbrt" 12 +Initial logical block reference tag +.IP "lr" 12 +Limited retry +.IP "fua" 12 +Force unit access +.IP "nr" 12 +Number of ranges +.IP "dspec" 12 +Directive specific value +.IP "lbatm" 12 +Logical block application tag mask +.IP "lbat" 12 +Logical block application tag +.IP "prinfor" 12 +Protection information field for read +.IP "prinfow" 12 +Protection information field for write +.IP "dtype" 12 +Directive type +.IP "format" 12 +Descriptor format diff --git a/doc/man/nvme_copy_range.2 b/doc/man/nvme_copy_range.2 new file mode 100644 index 0000000..590d4f1 --- /dev/null +++ b/doc/man/nvme_copy_range.2 @@ -0,0 +1,39 @@ +.TH "libnvme" 9 "struct nvme_copy_range" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_copy_range \- +.SH SYNOPSIS +struct nvme_copy_range { +.br +.BI " __u8 rsvd0[8];" +.br +.BI " __le64 slba;" +.br +.BI " __le16 nlb;" +.br +.BI " __u8 rsvd18[6];" +.br +.BI " __le32 eilbrt;" +.br +.BI " __le16 elbatm;" +.br +.BI " __le16 elbat;" +.br +.BI " +}; +.br + +.SH Members +.IP "rsvd0" 12 +Reserved +.IP "slba" 12 +Starting LBA +.IP "nlb" 12 +Number of Logical Blocks +.IP "rsvd18" 12 +Reserved +.IP "eilbrt" 12 +Expected Initial Logical Block Reference Tag +.IP "elbatm" 12 +Expected Logical Block Application Tag Mask +.IP "elbat" 12 +Expected Logical Block Application Tag diff --git a/doc/man/nvme_create_ctrl.2 b/doc/man/nvme_create_ctrl.2 new file mode 100644 index 0000000..8cab856 --- /dev/null +++ b/doc/man/nvme_create_ctrl.2 @@ -0,0 +1,31 @@ +.TH "nvme_create_ctrl" 9 "nvme_create_ctrl" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_create_ctrl \- Allocate an unconnected NVMe controller +.SH SYNOPSIS +.B "nvme_ctrl_t" nvme_create_ctrl +.BI "(nvme_root_t r " "," +.BI "const char *subsysnqn " "," +.BI "const char *transport " "," +.BI "const char *traddr " "," +.BI "const char *host_traddr " "," +.BI "const char *host_iface " "," +.BI "const char *trsvcid " ");" +.SH ARGUMENTS +.IP "r" 12 +NVMe root element +.IP "subsysnqn" 12 +Subsystem NQN +.IP "transport" 12 +Transport type +.IP "traddr" 12 +Transport address +.IP "host_traddr" 12 +Host transport address +.IP "host_iface" 12 +Host interface name +.IP "trsvcid" 12 +Transport service ID +.SH "DESCRIPTION" +Creates an unconnected controller to be used for \fBnvme_add_ctrl\fP. +.SH "RETURN" +Controller instance diff --git a/doc/man/nvme_create_root.2 b/doc/man/nvme_create_root.2 new file mode 100644 index 0000000..fc8cdab --- /dev/null +++ b/doc/man/nvme_create_root.2 @@ -0,0 +1,14 @@ +.TH "nvme_create_root" 9 "nvme_create_root" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_create_root \- Initialize root object +.SH SYNOPSIS +.B "nvme_root_t" nvme_create_root +.BI "(FILE *fp " "," +.BI "int log_level " ");" +.SH ARGUMENTS +.IP "fp" 12 +File descriptor for logging messages +.IP "log_level" 12 +Logging level to use +.SH "RETURN" +Initialized \fInvme_root_t\fP object diff --git a/doc/man/nvme_csi.2 b/doc/man/nvme_csi.2 new file mode 100644 index 0000000..0a8523c --- /dev/null +++ b/doc/man/nvme_csi.2 @@ -0,0 +1,24 @@ +.TH "libnvme" 9 "enum nvme_csi" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_csi \- Defined command set indicators +.SH SYNOPSIS +enum nvme_csi { +.br +.BI " NVME_CSI_NVM" +, +.br +.br +.BI " NVME_CSI_KV" +, +.br +.br +.BI " NVME_CSI_ZNS" + +}; +.SH Constants +.IP "NVME_CSI_NVM" 12 +NVM Command Set Indicator +.IP "NVME_CSI_KV" 12 +Key Value Command Set +.IP "NVME_CSI_ZNS" 12 +Zoned Namespace Command Set diff --git a/doc/man/nvme_ctrl_first_ns.2 b/doc/man/nvme_ctrl_first_ns.2 new file mode 100644 index 0000000..a8ef754 --- /dev/null +++ b/doc/man/nvme_ctrl_first_ns.2 @@ -0,0 +1,11 @@ +.TH "nvme_ctrl_first_ns" 9 "nvme_ctrl_first_ns" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_first_ns \- Start namespace iterator +.SH SYNOPSIS +.B "nvme_ns_t" nvme_ctrl_first_ns +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.SH "RETURN" +First \fInvme_ns_t\fP object of an \fIc\fP iterator diff --git a/doc/man/nvme_ctrl_first_path.2 b/doc/man/nvme_ctrl_first_path.2 new file mode 100644 index 0000000..606feef --- /dev/null +++ b/doc/man/nvme_ctrl_first_path.2 @@ -0,0 +1,11 @@ +.TH "nvme_ctrl_first_path" 9 "nvme_ctrl_first_path" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_first_path \- Start path iterator +.SH SYNOPSIS +.B "nvme_path_t" nvme_ctrl_first_path +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.SH "RETURN" +First \fInvme_path_t\fP object of an \fIc\fP iterator diff --git a/doc/man/nvme_ctrl_for_each_ns.2 b/doc/man/nvme_ctrl_for_each_ns.2 new file mode 100644 index 0000000..97b08b1 --- /dev/null +++ b/doc/man/nvme_ctrl_for_each_ns.2 @@ -0,0 +1,12 @@ +.TH "nvme_ctrl_for_each_ns" 9 "nvme_ctrl_for_each_ns" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_for_each_ns \- Traverse namespaces +.SH SYNOPSIS +.B "nvme_ctrl_for_each_ns +.BI "(c " "," +.BI "n " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.IP "n" 12 +\fInvme_ns_t\fP object diff --git a/doc/man/nvme_ctrl_for_each_ns_safe.2 b/doc/man/nvme_ctrl_for_each_ns_safe.2 new file mode 100644 index 0000000..844a7c7 --- /dev/null +++ b/doc/man/nvme_ctrl_for_each_ns_safe.2 @@ -0,0 +1,15 @@ +.TH "nvme_ctrl_for_each_ns_safe" 9 "nvme_ctrl_for_each_ns_safe" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_for_each_ns_safe \- Traverse namespaces +.SH SYNOPSIS +.B "nvme_ctrl_for_each_ns_safe +.BI "(c " "," +.BI "n " "," +.BI "_n " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.IP "n" 12 +\fInvme_ns_t\fP object +.IP "_n" 12 +A \fInvme_ns_t_node\fP to use as temporary storage diff --git a/doc/man/nvme_ctrl_for_each_path.2 b/doc/man/nvme_ctrl_for_each_path.2 new file mode 100644 index 0000000..ad85b94 --- /dev/null +++ b/doc/man/nvme_ctrl_for_each_path.2 @@ -0,0 +1,12 @@ +.TH "nvme_ctrl_for_each_path" 9 "nvme_ctrl_for_each_path" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_for_each_path \- Traverse paths +.SH SYNOPSIS +.B "nvme_ctrl_for_each_path +.BI "(c " "," +.BI "p " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.IP "p" 12 +\fInvme_path_t\fP object diff --git a/doc/man/nvme_ctrl_for_each_path_safe.2 b/doc/man/nvme_ctrl_for_each_path_safe.2 new file mode 100644 index 0000000..b341119 --- /dev/null +++ b/doc/man/nvme_ctrl_for_each_path_safe.2 @@ -0,0 +1,15 @@ +.TH "nvme_ctrl_for_each_path_safe" 9 "nvme_ctrl_for_each_path_safe" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_for_each_path_safe \- Traverse paths +.SH SYNOPSIS +.B "nvme_ctrl_for_each_path_safe +.BI "(c " "," +.BI "p " "," +.BI "_p " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.IP "p" 12 +\fInvme_path_t\fP object +.IP "_p" 12 +A \fInvme_path_t_node\fP to use as temporary storage diff --git a/doc/man/nvme_ctrl_get_address.2 b/doc/man/nvme_ctrl_get_address.2 new file mode 100644 index 0000000..559a5de --- /dev/null +++ b/doc/man/nvme_ctrl_get_address.2 @@ -0,0 +1,12 @@ +.TH "nvme_ctrl_get_address" 9 "nvme_ctrl_get_address" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_get_address \- Address string of a controller +.SH SYNOPSIS +.B "const char *" nvme_ctrl_get_address +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.SH "RETURN" +NVMe-over-Fabrics address string of \fIc\fP or empty string +of no address is present. diff --git a/doc/man/nvme_ctrl_get_config.2 b/doc/man/nvme_ctrl_get_config.2 new file mode 100644 index 0000000..130de7e --- /dev/null +++ b/doc/man/nvme_ctrl_get_config.2 @@ -0,0 +1,11 @@ +.TH "nvme_ctrl_get_config" 9 "nvme_ctrl_get_config" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_get_config \- Fabrics configuration of a controller +.SH SYNOPSIS +.B "struct nvme_fabrics_config *" nvme_ctrl_get_config +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.SH "RETURN" +Fabrics configuration of \fIc\fP diff --git a/doc/man/nvme_ctrl_get_dhchap_key.2 b/doc/man/nvme_ctrl_get_dhchap_key.2 new file mode 100644 index 0000000..e9191da --- /dev/null +++ b/doc/man/nvme_ctrl_get_dhchap_key.2 @@ -0,0 +1,11 @@ +.TH "nvme_ctrl_get_dhchap_key" 9 "nvme_ctrl_get_dhchap_key" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_get_dhchap_key \- Return controller key +.SH SYNOPSIS +.B "const char *" nvme_ctrl_get_dhchap_key +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller for which the key should be set +.SH "RETURN" +DH-HMAC-CHAP controller key or NULL if not set diff --git a/doc/man/nvme_ctrl_get_fd.2 b/doc/man/nvme_ctrl_get_fd.2 new file mode 100644 index 0000000..699c823 --- /dev/null +++ b/doc/man/nvme_ctrl_get_fd.2 @@ -0,0 +1,11 @@ +.TH "nvme_ctrl_get_fd" 9 "nvme_ctrl_get_fd" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_get_fd \- Get associated file descriptor +.SH SYNOPSIS +.B "int" nvme_ctrl_get_fd +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.SH "RETURN" +File descriptor associated with \fIc\fP or -1 diff --git a/doc/man/nvme_ctrl_get_firmware.2 b/doc/man/nvme_ctrl_get_firmware.2 new file mode 100644 index 0000000..9072a2a --- /dev/null +++ b/doc/man/nvme_ctrl_get_firmware.2 @@ -0,0 +1,11 @@ +.TH "nvme_ctrl_get_firmware" 9 "nvme_ctrl_get_firmware" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_get_firmware \- Firmware string of a controller +.SH SYNOPSIS +.B "const char *" nvme_ctrl_get_firmware +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.SH "RETURN" +Firmware string of \fIc\fP diff --git a/doc/man/nvme_ctrl_get_host_iface.2 b/doc/man/nvme_ctrl_get_host_iface.2 new file mode 100644 index 0000000..792795b --- /dev/null +++ b/doc/man/nvme_ctrl_get_host_iface.2 @@ -0,0 +1,11 @@ +.TH "nvme_ctrl_get_host_iface" 9 "nvme_ctrl_get_host_iface" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_get_host_iface \- Host interface name of a controller +.SH SYNOPSIS +.B "const char *" nvme_ctrl_get_host_iface +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.SH "RETURN" +Host interface name of \fIc\fP (if present) diff --git a/doc/man/nvme_ctrl_get_host_traddr.2 b/doc/man/nvme_ctrl_get_host_traddr.2 new file mode 100644 index 0000000..7972169 --- /dev/null +++ b/doc/man/nvme_ctrl_get_host_traddr.2 @@ -0,0 +1,11 @@ +.TH "nvme_ctrl_get_host_traddr" 9 "nvme_ctrl_get_host_traddr" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_get_host_traddr \- Host transport address of a controller +.SH SYNOPSIS +.B "const char *" nvme_ctrl_get_host_traddr +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.SH "RETURN" +Host transport address of \fIc\fP (if present) diff --git a/doc/man/nvme_ctrl_get_model.2 b/doc/man/nvme_ctrl_get_model.2 new file mode 100644 index 0000000..41b5b50 --- /dev/null +++ b/doc/man/nvme_ctrl_get_model.2 @@ -0,0 +1,11 @@ +.TH "nvme_ctrl_get_model" 9 "nvme_ctrl_get_model" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_get_model \- Model of a controller +.SH SYNOPSIS +.B "const char *" nvme_ctrl_get_model +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.SH "RETURN" +Model string of \fIc\fP diff --git a/doc/man/nvme_ctrl_get_name.2 b/doc/man/nvme_ctrl_get_name.2 new file mode 100644 index 0000000..022766a --- /dev/null +++ b/doc/man/nvme_ctrl_get_name.2 @@ -0,0 +1,11 @@ +.TH "nvme_ctrl_get_name" 9 "nvme_ctrl_get_name" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_get_name \- sysfs name of a controller +.SH SYNOPSIS +.B "const char *" nvme_ctrl_get_name +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.SH "RETURN" +sysfs name of \fIc\fP diff --git a/doc/man/nvme_ctrl_get_numa_node.2 b/doc/man/nvme_ctrl_get_numa_node.2 new file mode 100644 index 0000000..06e199f --- /dev/null +++ b/doc/man/nvme_ctrl_get_numa_node.2 @@ -0,0 +1,11 @@ +.TH "nvme_ctrl_get_numa_node" 9 "nvme_ctrl_get_numa_node" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_get_numa_node \- NUMA node of a controller +.SH SYNOPSIS +.B "const char *" nvme_ctrl_get_numa_node +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.SH "RETURN" +String indicating the NUMA node diff --git a/doc/man/nvme_ctrl_get_queue_count.2 b/doc/man/nvme_ctrl_get_queue_count.2 new file mode 100644 index 0000000..0645e4a --- /dev/null +++ b/doc/man/nvme_ctrl_get_queue_count.2 @@ -0,0 +1,11 @@ +.TH "nvme_ctrl_get_queue_count" 9 "nvme_ctrl_get_queue_count" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_get_queue_count \- Queue count of a controller +.SH SYNOPSIS +.B "const char *" nvme_ctrl_get_queue_count +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.SH "RETURN" +Queue count of \fIc\fP diff --git a/doc/man/nvme_ctrl_get_serial.2 b/doc/man/nvme_ctrl_get_serial.2 new file mode 100644 index 0000000..646c43c --- /dev/null +++ b/doc/man/nvme_ctrl_get_serial.2 @@ -0,0 +1,11 @@ +.TH "nvme_ctrl_get_serial" 9 "nvme_ctrl_get_serial" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_get_serial \- Serial number of a controller +.SH SYNOPSIS +.B "const char *" nvme_ctrl_get_serial +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Conroller instance +.SH "RETURN" +Serial number string of \fIc\fP diff --git a/doc/man/nvme_ctrl_get_sqsize.2 b/doc/man/nvme_ctrl_get_sqsize.2 new file mode 100644 index 0000000..2ee323a --- /dev/null +++ b/doc/man/nvme_ctrl_get_sqsize.2 @@ -0,0 +1,11 @@ +.TH "nvme_ctrl_get_sqsize" 9 "nvme_ctrl_get_sqsize" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_get_sqsize \- SQ size of a controller +.SH SYNOPSIS +.B "const char *" nvme_ctrl_get_sqsize +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.SH "RETURN" +SQ size (as string) of \fIc\fP diff --git a/doc/man/nvme_ctrl_get_state.2 b/doc/man/nvme_ctrl_get_state.2 new file mode 100644 index 0000000..8114541 --- /dev/null +++ b/doc/man/nvme_ctrl_get_state.2 @@ -0,0 +1,11 @@ +.TH "nvme_ctrl_get_state" 9 "nvme_ctrl_get_state" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_get_state \- Running state of an controller +.SH SYNOPSIS +.B "const char *" nvme_ctrl_get_state +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.SH "RETURN" +String indicating the running state of \fIc\fP diff --git a/doc/man/nvme_ctrl_get_subsysnqn.2 b/doc/man/nvme_ctrl_get_subsysnqn.2 new file mode 100644 index 0000000..13ae3f2 --- /dev/null +++ b/doc/man/nvme_ctrl_get_subsysnqn.2 @@ -0,0 +1,11 @@ +.TH "nvme_ctrl_get_subsysnqn" 9 "nvme_ctrl_get_subsysnqn" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_get_subsysnqn \- Subsystem NQN of a controller +.SH SYNOPSIS +.B "const char *" nvme_ctrl_get_subsysnqn +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.SH "RETURN" +Subsystem NQN of \fIc\fP diff --git a/doc/man/nvme_ctrl_get_subsystem.2 b/doc/man/nvme_ctrl_get_subsystem.2 new file mode 100644 index 0000000..d522928 --- /dev/null +++ b/doc/man/nvme_ctrl_get_subsystem.2 @@ -0,0 +1,11 @@ +.TH "nvme_ctrl_get_subsystem" 9 "nvme_ctrl_get_subsystem" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_get_subsystem \- Parent subsystem of a controller +.SH SYNOPSIS +.B "nvme_subsystem_t" nvme_ctrl_get_subsystem +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.SH "RETURN" +Parent nvme_subsystem_t object diff --git a/doc/man/nvme_ctrl_get_sysfs_dir.2 b/doc/man/nvme_ctrl_get_sysfs_dir.2 new file mode 100644 index 0000000..fb7973e --- /dev/null +++ b/doc/man/nvme_ctrl_get_sysfs_dir.2 @@ -0,0 +1,11 @@ +.TH "nvme_ctrl_get_sysfs_dir" 9 "nvme_ctrl_get_sysfs_dir" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_get_sysfs_dir \- sysfs directory of a controller +.SH SYNOPSIS +.B "const char *" nvme_ctrl_get_sysfs_dir +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.SH "RETURN" +sysfs directory name of \fIc\fP diff --git a/doc/man/nvme_ctrl_get_traddr.2 b/doc/man/nvme_ctrl_get_traddr.2 new file mode 100644 index 0000000..bf6963e --- /dev/null +++ b/doc/man/nvme_ctrl_get_traddr.2 @@ -0,0 +1,11 @@ +.TH "nvme_ctrl_get_traddr" 9 "nvme_ctrl_get_traddr" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_get_traddr \- Transport address of a controller +.SH SYNOPSIS +.B "const char *" nvme_ctrl_get_traddr +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.SH "RETURN" +Transport address of \fIc\fP diff --git a/doc/man/nvme_ctrl_get_transport.2 b/doc/man/nvme_ctrl_get_transport.2 new file mode 100644 index 0000000..e7acdfa --- /dev/null +++ b/doc/man/nvme_ctrl_get_transport.2 @@ -0,0 +1,11 @@ +.TH "nvme_ctrl_get_transport" 9 "nvme_ctrl_get_transport" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_get_transport \- Transport type of a controller +.SH SYNOPSIS +.B "const char *" nvme_ctrl_get_transport +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.SH "RETURN" +Transport type of \fIc\fP diff --git a/doc/man/nvme_ctrl_get_trsvcid.2 b/doc/man/nvme_ctrl_get_trsvcid.2 new file mode 100644 index 0000000..b889a6c --- /dev/null +++ b/doc/man/nvme_ctrl_get_trsvcid.2 @@ -0,0 +1,11 @@ +.TH "nvme_ctrl_get_trsvcid" 9 "nvme_ctrl_get_trsvcid" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_get_trsvcid \- Transport service identifier of a controller +.SH SYNOPSIS +.B "const char *" nvme_ctrl_get_trsvcid +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.SH "RETURN" +Transport service identifier of \fIc\fP (if present) diff --git a/doc/man/nvme_ctrl_identify.2 b/doc/man/nvme_ctrl_identify.2 new file mode 100644 index 0000000..1bd849a --- /dev/null +++ b/doc/man/nvme_ctrl_identify.2 @@ -0,0 +1,17 @@ +.TH "nvme_ctrl_identify" 9 "nvme_ctrl_identify" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_identify \- Issues an 'identify controller' command +.SH SYNOPSIS +.B "int" nvme_ctrl_identify +.BI "(nvme_ctrl_t c " "," +.BI "struct nvme_id_ctrl *id " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.IP "id" 12 +Identify controller data structure +.SH "DESCRIPTION" +Issues an 'identify controller' command to \fIc\fP and copies the +data into \fIid\fP. +.SH "RETURN" +0 on success or -1 on failure. diff --git a/doc/man/nvme_ctrl_is_discovered.2 b/doc/man/nvme_ctrl_is_discovered.2 new file mode 100644 index 0000000..70d0ebe --- /dev/null +++ b/doc/man/nvme_ctrl_is_discovered.2 @@ -0,0 +1,11 @@ +.TH "nvme_ctrl_is_discovered" 9 "nvme_ctrl_is_discovered" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_is_discovered \- Returns the value of the 'discovered' flag +.SH SYNOPSIS +.B "bool" nvme_ctrl_is_discovered +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.SH "RETURN" +Value of the 'discovered' flag of \fIc\fP diff --git a/doc/man/nvme_ctrl_is_discovery_ctrl.2 b/doc/man/nvme_ctrl_is_discovery_ctrl.2 new file mode 100644 index 0000000..2255323 --- /dev/null +++ b/doc/man/nvme_ctrl_is_discovery_ctrl.2 @@ -0,0 +1,14 @@ +.TH "nvme_ctrl_is_discovery_ctrl" 9 "nvme_ctrl_is_discovery_ctrl" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_is_discovery_ctrl \- Check the 'discovery_ctrl' flag +.SH SYNOPSIS +.B "bool" nvme_ctrl_is_discovery_ctrl +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller to be checked +.SH "DESCRIPTION" +Returns the value of the 'discovery_ctrl' flag which specifies whether +\fIc\fP connects to a discovery subsystem. +.SH "RETURN" +Value of the 'discover_ctrl' flag diff --git a/doc/man/nvme_ctrl_is_persistent.2 b/doc/man/nvme_ctrl_is_persistent.2 new file mode 100644 index 0000000..9af269c --- /dev/null +++ b/doc/man/nvme_ctrl_is_persistent.2 @@ -0,0 +1,11 @@ +.TH "nvme_ctrl_is_persistent" 9 "nvme_ctrl_is_persistent" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_is_persistent \- Returns the value of the 'persistent' flag +.SH SYNOPSIS +.B "bool" nvme_ctrl_is_persistent +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.SH "RETURN" +Value of the 'persistent' flag of \fIc\fP diff --git a/doc/man/nvme_ctrl_list.2 b/doc/man/nvme_ctrl_list.2 new file mode 100644 index 0000000..85e11af --- /dev/null +++ b/doc/man/nvme_ctrl_list.2 @@ -0,0 +1,19 @@ +.TH "libnvme" 9 "struct nvme_ctrl_list" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_ctrl_list \- +.SH SYNOPSIS +struct nvme_ctrl_list { +.br +.BI " __le16 num;" +.br +.BI " __le16 identifier[NVME_ID_CTRL_LIST_MAX];" +.br +.BI " +}; +.br + +.SH Members +.IP "num" 12 +Number of Identifiers +.IP "identifier" 12 +NVM subsystem unique controller identifier diff --git a/doc/man/nvme_ctrl_metadata_type.2 b/doc/man/nvme_ctrl_metadata_type.2 new file mode 100644 index 0000000..eed88d8 --- /dev/null +++ b/doc/man/nvme_ctrl_metadata_type.2 @@ -0,0 +1,108 @@ +.TH "libnvme" 9 "enum nvme_ctrl_metadata_type" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_ctrl_metadata_type \- Controller Metadata Element Types +.SH SYNOPSIS +enum nvme_ctrl_metadata_type { +.br +.BI " NVME_CTRL_METADATA_OS_CTRL_NAME" +, +.br +.br +.BI " NVME_CTRL_METADATA_OS_DRIVER_NAME" +, +.br +.br +.BI " NVME_CTRL_METADATA_OS_DRIVER_VER" +, +.br +.br +.BI " NVME_CTRL_METADATA_PRE_BOOT_CTRL_NAME" +, +.br +.br +.BI " NVME_CTRL_METADATA_PRE_BOOT_DRIVER_NAME" +, +.br +.br +.BI " NVME_CTRL_METADATA_PRE_BOOT_DRIVER_VER" +, +.br +.br +.BI " NVME_CTRL_METADATA_SYS_PROC_MODEL" +, +.br +.br +.BI " NVME_CTRL_METADATA_CHIPSET_DRV_NAME" +, +.br +.br +.BI " NVME_CTRL_METADATA_CHIPSET_DRV_VERSION" +, +.br +.br +.BI " NVME_CTRL_METADATA_OS_NAME_AND_BUILD" +, +.br +.br +.BI " NVME_CTRL_METADATA_SYS_PROD_NAME" +, +.br +.br +.BI " NVME_CTRL_METADATA_FIRMWARE_VERSION" +, +.br +.br +.BI " NVME_CTRL_METADATA_OS_DRIVER_FILENAME" +, +.br +.br +.BI " NVME_CTRL_METADATA_DISPLAY_DRV_NAME" +, +.br +.br +.BI " NVME_CTRL_METADATA_DISPLAY_DRV_VERSION" +, +.br +.br +.BI " NVME_CTRL_METADATA_HOST_DET_FAIL_REC" + +}; +.SH Constants +.IP "NVME_CTRL_METADATA_OS_CTRL_NAME" 12 +Name of the controller in +the operating system. +.IP "NVME_CTRL_METADATA_OS_DRIVER_NAME" 12 +Name of the driver in the +operating system. +.IP "NVME_CTRL_METADATA_OS_DRIVER_VER" 12 +Version of the driver in +the operating system. +.IP "NVME_CTRL_METADATA_PRE_BOOT_CTRL_NAME" 12 +Name of the controller in +the pre-boot environment. +.IP "NVME_CTRL_METADATA_PRE_BOOT_DRIVER_NAME" 12 +Name of the driver in the +pre-boot environment. +.IP "NVME_CTRL_METADATA_PRE_BOOT_DRIVER_VER" 12 +Version of the driver in the +pre-boot environment. +.IP "NVME_CTRL_METADATA_SYS_PROC_MODEL" 12 +Model of the processor. +.IP "NVME_CTRL_METADATA_CHIPSET_DRV_NAME" 12 +Chipset driver name. +.IP "NVME_CTRL_METADATA_CHIPSET_DRV_VERSION" 12 +Chipsset driver version. +.IP "NVME_CTRL_METADATA_OS_NAME_AND_BUILD" 12 +Operating system name and build. +.IP "NVME_CTRL_METADATA_SYS_PROD_NAME" 12 +System product name. +.IP "NVME_CTRL_METADATA_FIRMWARE_VERSION" 12 +Host firmware (e.g UEFI) version. +.IP "NVME_CTRL_METADATA_OS_DRIVER_FILENAME" 12 +Operating system driver filename. +.IP "NVME_CTRL_METADATA_DISPLAY_DRV_NAME" 12 +Display driver name. +.IP "NVME_CTRL_METADATA_DISPLAY_DRV_VERSION" 12 +Display driver version. +.IP "NVME_CTRL_METADATA_HOST_DET_FAIL_REC" 12 +Failure record. diff --git a/doc/man/nvme_ctrl_next_ns.2 b/doc/man/nvme_ctrl_next_ns.2 new file mode 100644 index 0000000..194dcfc --- /dev/null +++ b/doc/man/nvme_ctrl_next_ns.2 @@ -0,0 +1,14 @@ +.TH "nvme_ctrl_next_ns" 9 "nvme_ctrl_next_ns" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_next_ns \- Next namespace iterator +.SH SYNOPSIS +.B "nvme_ns_t" nvme_ctrl_next_ns +.BI "(nvme_ctrl_t c " "," +.BI "nvme_ns_t n " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.IP "n" 12 +Previous nvme_ns_t iterator +.SH "RETURN" +Next nvme_ns_t object of an \fIc\fP iterator diff --git a/doc/man/nvme_ctrl_next_path.2 b/doc/man/nvme_ctrl_next_path.2 new file mode 100644 index 0000000..b494a73 --- /dev/null +++ b/doc/man/nvme_ctrl_next_path.2 @@ -0,0 +1,14 @@ +.TH "nvme_ctrl_next_path" 9 "nvme_ctrl_next_path" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_next_path \- Next path iterator +.SH SYNOPSIS +.B "nvme_path_t" nvme_ctrl_next_path +.BI "(nvme_ctrl_t c " "," +.BI "nvme_path_t p " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.IP "p" 12 +Previous \fInvme_path_t\fP object of an \fIc\fP iterator +.SH "RETURN" +Next \fInvme_path_t\fP object of an \fIc\fP iterator diff --git a/doc/man/nvme_ctrl_reset.2 b/doc/man/nvme_ctrl_reset.2 new file mode 100644 index 0000000..4912171 --- /dev/null +++ b/doc/man/nvme_ctrl_reset.2 @@ -0,0 +1,13 @@ +.TH "nvme_ctrl_reset" 9 "nvme_ctrl_reset" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_reset \- Initiate a controller reset +.SH SYNOPSIS +.B "int" nvme_ctrl_reset +.BI "(int fd " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.SH "DESCRIPTION" +This should only be sent to controller handles, not to namespaces. +.SH "RETURN" +0 if a reset was initiated or -1 with errno set otherwise. diff --git a/doc/man/nvme_ctrl_set_dhchap_key.2 b/doc/man/nvme_ctrl_set_dhchap_key.2 new file mode 100644 index 0000000..0e02292 --- /dev/null +++ b/doc/man/nvme_ctrl_set_dhchap_key.2 @@ -0,0 +1,12 @@ +.TH "nvme_ctrl_set_dhchap_key" 9 "nvme_ctrl_set_dhchap_key" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_set_dhchap_key \- Set controller key +.SH SYNOPSIS +.B "void" nvme_ctrl_set_dhchap_key +.BI "(nvme_ctrl_t c " "," +.BI "const char *key " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller for which the key should be set +.IP "key" 12 +DH-HMAC-CHAP Key to set or NULL to clear existing key diff --git a/doc/man/nvme_ctrl_set_discovered.2 b/doc/man/nvme_ctrl_set_discovered.2 new file mode 100644 index 0000000..f895e51 --- /dev/null +++ b/doc/man/nvme_ctrl_set_discovered.2 @@ -0,0 +1,14 @@ +.TH "nvme_ctrl_set_discovered" 9 "nvme_ctrl_set_discovered" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_set_discovered \- Set the 'discovered' flag +.SH SYNOPSIS +.B "void" nvme_ctrl_set_discovered +.BI "(nvme_ctrl_t c " "," +.BI "bool discovered " ");" +.SH ARGUMENTS +.IP "c" 12 +nvme_ctrl_t object +.IP "discovered" 12 +Value of the 'discovered' flag +.SH "DESCRIPTION" +Set the 'discovered' flag of \fIc\fP to \fIdiscovered\fP diff --git a/doc/man/nvme_ctrl_set_discovery_ctrl.2 b/doc/man/nvme_ctrl_set_discovery_ctrl.2 new file mode 100644 index 0000000..824d201 --- /dev/null +++ b/doc/man/nvme_ctrl_set_discovery_ctrl.2 @@ -0,0 +1,15 @@ +.TH "nvme_ctrl_set_discovery_ctrl" 9 "nvme_ctrl_set_discovery_ctrl" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_set_discovery_ctrl \- Set the 'discovery_ctrl' flag +.SH SYNOPSIS +.B "void" nvme_ctrl_set_discovery_ctrl +.BI "(nvme_ctrl_t c " "," +.BI "bool discovery " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller to be modified +.IP "discovery" 12 +value of the discovery_ctrl flag +.SH "DESCRIPTION" +Sets the 'discovery_ctrl' flag in \fIc\fP to specify whether +\fIc\fP connects to a discovery subsystem. diff --git a/doc/man/nvme_ctrl_set_persistent.2 b/doc/man/nvme_ctrl_set_persistent.2 new file mode 100644 index 0000000..6d70b36 --- /dev/null +++ b/doc/man/nvme_ctrl_set_persistent.2 @@ -0,0 +1,14 @@ +.TH "nvme_ctrl_set_persistent" 9 "nvme_ctrl_set_persistent" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrl_set_persistent \- Set the 'persistent' flag +.SH SYNOPSIS +.B "void" nvme_ctrl_set_persistent +.BI "(nvme_ctrl_t c " "," +.BI "bool persistent " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.IP "persistent" 12 +value of the 'persistent' flag +.SH "DESCRIPTION" +Set the 'persistent' flag of \fIc\fP to \fIpersistent\fP diff --git a/doc/man/nvme_ctrls_filter.2 b/doc/man/nvme_ctrls_filter.2 new file mode 100644 index 0000000..59aeaaf --- /dev/null +++ b/doc/man/nvme_ctrls_filter.2 @@ -0,0 +1,11 @@ +.TH "nvme_ctrls_filter" 9 "nvme_ctrls_filter" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ctrls_filter \- Filter for controllers +.SH SYNOPSIS +.B "int" nvme_ctrls_filter +.BI "(const struct dirent *d " ");" +.SH ARGUMENTS +.IP "d" 12 +dirent to check +.SH "RETURN" +1 if \fId\fP matches, 0 otherwise diff --git a/doc/man/nvme_default_host.2 b/doc/man/nvme_default_host.2 new file mode 100644 index 0000000..73ebb07 --- /dev/null +++ b/doc/man/nvme_default_host.2 @@ -0,0 +1,14 @@ +.TH "nvme_default_host" 9 "nvme_default_host" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_default_host \- Initializes the default host +.SH SYNOPSIS +.B "nvme_host_t" nvme_default_host +.BI "(nvme_root_t r " ");" +.SH ARGUMENTS +.IP "r" 12 +\fInvme_root_t\fP object +.SH "DESCRIPTION" +Initializes the default host object based on the values in +/etc/nvme/hostnqn and /etc/nvme/hostid and attaches it to \fIr\fP. +.SH "RETURN" +\fInvme_host_t\fP object diff --git a/doc/man/nvme_dev_self_test.2 b/doc/man/nvme_dev_self_test.2 new file mode 100644 index 0000000..b0d6d9e --- /dev/null +++ b/doc/man/nvme_dev_self_test.2 @@ -0,0 +1,23 @@ +.TH "nvme_dev_self_test" 9 "nvme_dev_self_test" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_dev_self_test \- Start or abort a self test +.SH SYNOPSIS +.B "int" nvme_dev_self_test +.BI "(struct nvme_dev_self_test_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_dev_self_test\fP argument structure +.SH "DESCRIPTION" +The Device Self-test command starts a device self-test operation or abort a +device self-test operation. A device self-test operation is a diagnostic +testing sequence that tests the integrity and functionality of the +controller and may include testing of the media associated with namespaces. +The controller may return a response to this command immediately while +running the self-test in the background. + +Set the 'nsid' field to 0 to not include namepsaces in the test. Set to +0xffffffff to test all namespaces. All other values tests a specific +namespace, if present. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_dev_self_test_args.2 b/doc/man/nvme_dev_self_test_args.2 new file mode 100644 index 0000000..a8cfb35 --- /dev/null +++ b/doc/man/nvme_dev_self_test_args.2 @@ -0,0 +1,35 @@ +.TH "libnvme" 9 "struct nvme_dev_self_test_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_dev_self_test_args \- Arguments for the NVMe Device Self Test command +.SH SYNOPSIS +struct nvme_dev_self_test_args { +.br +.BI " __u32 *result;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u32 nsid;" +.br +.BI " enum nvme_dst_stc stc;" +.br +.BI " +}; +.br + +.SH Members +.IP "result" 12 +The command completion result from CQE dword0 +.IP "args_size" 12 +Size of \fIstruct nvme_dev_self_test_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "nsid" 12 +Namespace ID to test +.IP "stc" 12 +Self test code, see \fIenum nvme_dst_stc\fP diff --git a/doc/man/nvme_dim_args.2 b/doc/man/nvme_dim_args.2 new file mode 100644 index 0000000..8a674eb --- /dev/null +++ b/doc/man/nvme_dim_args.2 @@ -0,0 +1,39 @@ +.TH "libnvme" 9 "struct nvme_dim_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_dim_args \- Arguments for the Discovery Information Management (DIM) command +.SH SYNOPSIS +struct nvme_dim_args { +.br +.BI " __u32 *result;" +.br +.BI " void *data;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u32 data_len;" +.br +.BI " __u8 tas;" +.br +.BI " +}; +.br + +.SH Members +.IP "result" 12 +Set on completion to the command's CQE DWORD 0 controller response. +.IP "data" 12 +Pointer to the DIM data +.IP "args_size" 12 +Length of the structure +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "data_len" 12 +Length of \fIdata\fP +.IP "tas" 12 +Task field of the Command Dword 10 (cdw10) diff --git a/doc/man/nvme_directive_dtype.2 b/doc/man/nvme_directive_dtype.2 new file mode 100644 index 0000000..e50bc32 --- /dev/null +++ b/doc/man/nvme_directive_dtype.2 @@ -0,0 +1,18 @@ +.TH "libnvme" 9 "enum nvme_directive_dtype" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_directive_dtype \- +.SH SYNOPSIS +enum nvme_directive_dtype { +.br +.BI " NVME_DIRECTIVE_DTYPE_IDENTIFY" +, +.br +.br +.BI " NVME_DIRECTIVE_DTYPE_STREAMS" + +}; +.SH Constants +.IP "NVME_DIRECTIVE_DTYPE_IDENTIFY" 12 +Identify directive type +.IP "NVME_DIRECTIVE_DTYPE_STREAMS" 12 +Streams directive type diff --git a/doc/man/nvme_directive_receive_doper.2 b/doc/man/nvme_directive_receive_doper.2 new file mode 100644 index 0000000..0095be2 --- /dev/null +++ b/doc/man/nvme_directive_receive_doper.2 @@ -0,0 +1,26 @@ +.TH "libnvme" 9 "enum nvme_directive_receive_doper" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_directive_receive_doper \- +.SH SYNOPSIS +enum nvme_directive_receive_doper { +.br +.BI " NVME_DIRECTIVE_RECEIVE_IDENTIFY_DOPER_PARAM" +, +.br +.br +.BI " NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_PARAM" +, +.br +.br +.BI " NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_STATUS" +, +.br +.br +.BI " NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_RESOURCE" + +}; +.SH Constants +.IP "NVME_DIRECTIVE_RECEIVE_IDENTIFY_DOPER_PARAM" 12 +.IP "NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_PARAM" 12 +.IP "NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_STATUS" 12 +.IP "NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_RESOURCE" 12 diff --git a/doc/man/nvme_directive_recv.2 b/doc/man/nvme_directive_recv.2 new file mode 100644 index 0000000..ae3802e --- /dev/null +++ b/doc/man/nvme_directive_recv.2 @@ -0,0 +1,12 @@ +.TH "nvme_directive_recv" 9 "nvme_directive_recv" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_directive_recv \- Receive directive specific data +.SH SYNOPSIS +.B "int" nvme_directive_recv +.BI "(struct nvme_directive_recv_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_directive_recv_args\fP argument structure +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_directive_recv_args.2 b/doc/man/nvme_directive_recv_args.2 new file mode 100644 index 0000000..83345ef --- /dev/null +++ b/doc/man/nvme_directive_recv_args.2 @@ -0,0 +1,55 @@ +.TH "libnvme" 9 "struct nvme_directive_recv_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_directive_recv_args \- Arguments for the NVMe Directive Receive command +.SH SYNOPSIS +struct nvme_directive_recv_args { +.br +.BI " __u32 *result;" +.br +.BI " void *data;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u32 nsid;" +.br +.BI " enum nvme_directive_receive_doper doper;" +.br +.BI " enum nvme_directive_dtype dtype;" +.br +.BI " __u32 cdw12;" +.br +.BI " __u32 data_len;" +.br +.BI " __u16 dspec;" +.br +.BI " +}; +.br + +.SH Members +.IP "result" 12 +If successful, the CQE dword0 value +.IP "data" 12 +Usespace address of data payload +.IP "args_size" 12 +Size of \fIstruct nvme_directive_recv_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "nsid" 12 +Namespace ID, if applicable +.IP "doper" 12 +Directive send operation, see \fIenum nvme_directive_send_doper\fP +.IP "dtype" 12 +Directive type, see \fIenum nvme_directive_dtype\fP +.IP "cdw12" 12 +Directive specific command dword12 +.IP "data_len" 12 +Length of data payload in bytes +.IP "dspec" 12 +Directive specific field diff --git a/doc/man/nvme_directive_recv_identify_parameters.2 b/doc/man/nvme_directive_recv_identify_parameters.2 new file mode 100644 index 0000000..d067edc --- /dev/null +++ b/doc/man/nvme_directive_recv_identify_parameters.2 @@ -0,0 +1,18 @@ +.TH "nvme_directive_recv_identify_parameters" 9 "nvme_directive_recv_identify_parameters" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_directive_recv_identify_parameters \- +.SH SYNOPSIS +.B "int" nvme_directive_recv_identify_parameters +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "struct nvme_id_directives *id " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Namespace ID +.IP "id" 12 +Identify parameters buffer +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_directive_recv_stream_allocate.2 b/doc/man/nvme_directive_recv_stream_allocate.2 new file mode 100644 index 0000000..24057ec --- /dev/null +++ b/doc/man/nvme_directive_recv_stream_allocate.2 @@ -0,0 +1,21 @@ +.TH "nvme_directive_recv_stream_allocate" 9 "nvme_directive_recv_stream_allocate" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_directive_recv_stream_allocate \- +.SH SYNOPSIS +.B "int" nvme_directive_recv_stream_allocate +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "__u16 nsr " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Namespace ID +.IP "nsr" 12 +Namespace Streams Requested +.IP "result" 12 +If successful, the CQE dword0 value +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_directive_recv_stream_parameters.2 b/doc/man/nvme_directive_recv_stream_parameters.2 new file mode 100644 index 0000000..fdcdec6 --- /dev/null +++ b/doc/man/nvme_directive_recv_stream_parameters.2 @@ -0,0 +1,18 @@ +.TH "nvme_directive_recv_stream_parameters" 9 "nvme_directive_recv_stream_parameters" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_directive_recv_stream_parameters \- +.SH SYNOPSIS +.B "int" nvme_directive_recv_stream_parameters +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "struct nvme_streams_directive_params *parms " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Namespace ID +.IP "parms" 12 +Streams directive parameters buffer +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_directive_recv_stream_status.2 b/doc/man/nvme_directive_recv_stream_status.2 new file mode 100644 index 0000000..d3b20f2 --- /dev/null +++ b/doc/man/nvme_directive_recv_stream_status.2 @@ -0,0 +1,21 @@ +.TH "nvme_directive_recv_stream_status" 9 "nvme_directive_recv_stream_status" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_directive_recv_stream_status \- +.SH SYNOPSIS +.B "int" nvme_directive_recv_stream_status +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "unsigned nr_entries " "," +.BI "struct nvme_streams_directive_status *id " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Namespace ID +.IP "nr_entries" 12 +Number of streams to receive +.IP "id" 12 +Stream status buffer +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_directive_send.2 b/doc/man/nvme_directive_send.2 new file mode 100644 index 0000000..af9d0fc --- /dev/null +++ b/doc/man/nvme_directive_send.2 @@ -0,0 +1,18 @@ +.TH "nvme_directive_send" 9 "nvme_directive_send" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_directive_send \- Send directive command +.SH SYNOPSIS +.B "int" nvme_directive_send +.BI "(struct nvme_directive_send_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_directive_send_args\fP argument structure +.SH "DESCRIPTION" +Directives is a mechanism to enable host and NVM subsystem or controller +information exchange. The Directive Send command transfers data related to a +specific Directive Type from the host to the controller. + +See the NVMe specification for more information. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_directive_send_args.2 b/doc/man/nvme_directive_send_args.2 new file mode 100644 index 0000000..d8de887 --- /dev/null +++ b/doc/man/nvme_directive_send_args.2 @@ -0,0 +1,55 @@ +.TH "libnvme" 9 "struct nvme_directive_send_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_directive_send_args \- Arguments for the NVMe Directive Send command +.SH SYNOPSIS +struct nvme_directive_send_args { +.br +.BI " __u32 *result;" +.br +.BI " void *data;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u32 nsid;" +.br +.BI " enum nvme_directive_send_doper doper;" +.br +.BI " enum nvme_directive_dtype dtype;" +.br +.BI " __u32 cdw12;" +.br +.BI " __u32 data_len;" +.br +.BI " __u16 dspec;" +.br +.BI " +}; +.br + +.SH Members +.IP "result" 12 +If successful, the CQE dword0 value +.IP "data" 12 +Data payload to to be send +.IP "args_size" 12 +Size of \fIstruct nvme_directive_send_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "nsid" 12 +Namespace ID, if applicable +.IP "doper" 12 +Directive send operation, see \fIenum nvme_directive_send_doper\fP +.IP "dtype" 12 +Directive type, see \fIenum nvme_directive_dtype\fP +.IP "cdw12" 12 +Directive specific command dword12 +.IP "data_len" 12 +Length of data payload in bytes +.IP "dspec" 12 +Directive specific field diff --git a/doc/man/nvme_directive_send_doper.2 b/doc/man/nvme_directive_send_doper.2 new file mode 100644 index 0000000..4d3ece1 --- /dev/null +++ b/doc/man/nvme_directive_send_doper.2 @@ -0,0 +1,21 @@ +.TH "libnvme" 9 "enum nvme_directive_send_doper" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_directive_send_doper \- +.SH SYNOPSIS +enum nvme_directive_send_doper { +.br +.BI " NVME_DIRECTIVE_SEND_IDENTIFY_DOPER_ENDIR" +, +.br +.br +.BI " NVME_DIRECTIVE_SEND_STREAMS_DOPER_RELEASE_IDENTIFIER" +, +.br +.br +.BI " NVME_DIRECTIVE_SEND_STREAMS_DOPER_RELEASE_RESOURCE" + +}; +.SH Constants +.IP "NVME_DIRECTIVE_SEND_IDENTIFY_DOPER_ENDIR" 12 +.IP "NVME_DIRECTIVE_SEND_STREAMS_DOPER_RELEASE_IDENTIFIER" 12 +.IP "NVME_DIRECTIVE_SEND_STREAMS_DOPER_RELEASE_RESOURCE" 12 diff --git a/doc/man/nvme_directive_send_id_endir.2 b/doc/man/nvme_directive_send_id_endir.2 new file mode 100644 index 0000000..c3b31ee --- /dev/null +++ b/doc/man/nvme_directive_send_id_endir.2 @@ -0,0 +1,24 @@ +.TH "nvme_directive_send_id_endir" 9 "nvme_directive_send_id_endir" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_directive_send_id_endir \- +.SH SYNOPSIS +.B "int" nvme_directive_send_id_endir +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "bool endir " "," +.BI "enum nvme_directive_dtype dtype " "," +.BI "struct nvme_id_directives *id " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Namespace Identifier +.IP "endir" 12 +Enable Directive +.IP "dtype" 12 +Directive Type +.IP "id" 12 +Pointer to structure nvme_id_directives +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_directive_send_identify_endir.2 b/doc/man/nvme_directive_send_identify_endir.2 new file mode 100644 index 0000000..f6cb007 --- /dev/null +++ b/doc/man/nvme_directive_send_identify_endir.2 @@ -0,0 +1,16 @@ +.TH "libnvme" 9 "enum nvme_directive_send_identify_endir" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_directive_send_identify_endir \- +.SH SYNOPSIS +enum nvme_directive_send_identify_endir { +.br +.BI " NVME_DIRECTIVE_SEND_IDENTIFY_ENDIR_DISABLE" +, +.br +.br +.BI " NVME_DIRECTIVE_SEND_IDENTIFY_ENDIR_ENABLE" + +}; +.SH Constants +.IP "NVME_DIRECTIVE_SEND_IDENTIFY_ENDIR_DISABLE" 12 +.IP "NVME_DIRECTIVE_SEND_IDENTIFY_ENDIR_ENABLE" 12 diff --git a/doc/man/nvme_directive_send_stream_release_identifier.2 b/doc/man/nvme_directive_send_stream_release_identifier.2 new file mode 100644 index 0000000..9768cd6 --- /dev/null +++ b/doc/man/nvme_directive_send_stream_release_identifier.2 @@ -0,0 +1,18 @@ +.TH "nvme_directive_send_stream_release_identifier" 9 "nvme_directive_send_stream_release_identifier" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_directive_send_stream_release_identifier \- +.SH SYNOPSIS +.B "int" nvme_directive_send_stream_release_identifier +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "__u16 stream_id " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Namespace ID +.IP "stream_id" 12 +Stream identifier +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_directive_send_stream_release_resource.2 b/doc/man/nvme_directive_send_stream_release_resource.2 new file mode 100644 index 0000000..32ebab4 --- /dev/null +++ b/doc/man/nvme_directive_send_stream_release_resource.2 @@ -0,0 +1,15 @@ +.TH "nvme_directive_send_stream_release_resource" 9 "nvme_directive_send_stream_release_resource" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_directive_send_stream_release_resource \- +.SH SYNOPSIS +.B "int" nvme_directive_send_stream_release_resource +.BI "(int fd " "," +.BI "__u32 nsid " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Namespace ID +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_directive_types.2 b/doc/man/nvme_directive_types.2 new file mode 100644 index 0000000..aa2e48c --- /dev/null +++ b/doc/man/nvme_directive_types.2 @@ -0,0 +1,18 @@ +.TH "libnvme" 9 "enum nvme_directive_types" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_directive_types \- +.SH SYNOPSIS +enum nvme_directive_types { +.br +.BI " NVME_ID_DIR_ID_BIT" +, +.br +.br +.BI " NVME_ID_DIR_SD_BIT" + +}; +.SH Constants +.IP "NVME_ID_DIR_ID_BIT" 12 +Identify directive is supported +.IP "NVME_ID_DIR_SD_BIT" 12 +Streams directive is supported diff --git a/doc/man/nvme_disconnect_ctrl.2 b/doc/man/nvme_disconnect_ctrl.2 new file mode 100644 index 0000000..35a8a0a --- /dev/null +++ b/doc/man/nvme_disconnect_ctrl.2 @@ -0,0 +1,13 @@ +.TH "nvme_disconnect_ctrl" 9 "nvme_disconnect_ctrl" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_disconnect_ctrl \- Disconnect a controller +.SH SYNOPSIS +.B "int" nvme_disconnect_ctrl +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.SH "DESCRIPTION" +Issues a 'disconnect' fabrics command to \fIc\fP +.SH "RETURN" +0 on success, -1 on failure. diff --git a/doc/man/nvme_dsm.2 b/doc/man/nvme_dsm.2 new file mode 100644 index 0000000..4803104 --- /dev/null +++ b/doc/man/nvme_dsm.2 @@ -0,0 +1,18 @@ +.TH "nvme_dsm" 9 "nvme_dsm" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_dsm \- Send an nvme data set management command +.SH SYNOPSIS +.B "int" nvme_dsm +.BI "(struct nvme_dsm_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_dsm_args\fP argument structure +.SH "DESCRIPTION" +The Dataset Management command is used by the host to indicate attributes +for ranges of logical blocks. This includes attributes like frequency that +data is read or written, access size, and other information that may be used +to optimize performance and reliability, and may be used to +deallocate/unmap/trim those logical blocks. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_dsm_args.2 b/doc/man/nvme_dsm_args.2 new file mode 100644 index 0000000..bb4f645 --- /dev/null +++ b/doc/man/nvme_dsm_args.2 @@ -0,0 +1,43 @@ +.TH "libnvme" 9 "struct nvme_dsm_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_dsm_args \- Arguments for the NVMe Dataset Management command +.SH SYNOPSIS +struct nvme_dsm_args { +.br +.BI " __u32 *result;" +.br +.BI " struct nvme_dsm_range *dsm;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u32 nsid;" +.br +.BI " __u32 attrs;" +.br +.BI " __u16 nr_ranges;" +.br +.BI " +}; +.br + +.SH Members +.IP "result" 12 +The command completion result from CQE dword0 +.IP "dsm" 12 +The data set management attributes +.IP "args_size" 12 +Size of \fIstruct nvme_dsm_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "nsid" 12 +Namespace identifier +.IP "attrs" 12 +DSM attributes, see \fIenum nvme_dsm_attributes\fP +.IP "nr_ranges" 12 +Number of block ranges in the data set management attributes diff --git a/doc/man/nvme_dsm_attributes.2 b/doc/man/nvme_dsm_attributes.2 new file mode 100644 index 0000000..1814d87 --- /dev/null +++ b/doc/man/nvme_dsm_attributes.2 @@ -0,0 +1,24 @@ +.TH "libnvme" 9 "enum nvme_dsm_attributes" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_dsm_attributes \- +.SH SYNOPSIS +enum nvme_dsm_attributes { +.br +.BI " NVME_DSMGMT_IDR" +, +.br +.br +.BI " NVME_DSMGMT_IDW" +, +.br +.br +.BI " NVME_DSMGMT_AD" + +}; +.SH Constants +.IP "NVME_DSMGMT_IDR" 12 +Attribute – Integral Dataset for Read +.IP "NVME_DSMGMT_IDW" 12 +Attribute – Integral Dataset for Write +.IP "NVME_DSMGMT_AD" 12 +Attribute – Deallocate diff --git a/doc/man/nvme_dsm_range.2 b/doc/man/nvme_dsm_range.2 new file mode 100644 index 0000000..1edd263 --- /dev/null +++ b/doc/man/nvme_dsm_range.2 @@ -0,0 +1,23 @@ +.TH "libnvme" 9 "struct nvme_dsm_range" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_dsm_range \- +.SH SYNOPSIS +struct nvme_dsm_range { +.br +.BI " __le32 cattr;" +.br +.BI " __le32 nlb;" +.br +.BI " __le64 slba;" +.br +.BI " +}; +.br + +.SH Members +.IP "cattr" 12 +Context Attributes +.IP "nlb" 12 +Length in logical blocks +.IP "slba" 12 +Starting LBA diff --git a/doc/man/nvme_dst_stc.2 b/doc/man/nvme_dst_stc.2 new file mode 100644 index 0000000..991a171 --- /dev/null +++ b/doc/man/nvme_dst_stc.2 @@ -0,0 +1,30 @@ +.TH "libnvme" 9 "enum nvme_dst_stc" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_dst_stc \- Action taken by the Device Self-test command +.SH SYNOPSIS +enum nvme_dst_stc { +.br +.BI " NVME_DST_STC_SHORT" +, +.br +.br +.BI " NVME_DST_STC_LONG" +, +.br +.br +.BI " NVME_DST_STC_VS" +, +.br +.br +.BI " NVME_DST_STC_ABORT" + +}; +.SH Constants +.IP "NVME_DST_STC_SHORT" 12 +Start a short device self-test operation +.IP "NVME_DST_STC_LONG" 12 +Start an extended device self-test operation +.IP "NVME_DST_STC_VS" 12 +Start a vendor specific device self-test operation +.IP "NVME_DST_STC_ABORT" 12 +Abort device self-test operation diff --git a/doc/man/nvme_dump_config.2 b/doc/man/nvme_dump_config.2 new file mode 100644 index 0000000..d3e9f1f --- /dev/null +++ b/doc/man/nvme_dump_config.2 @@ -0,0 +1,14 @@ +.TH "nvme_dump_config" 9 "nvme_dump_config" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_dump_config \- Print the JSON configuration +.SH SYNOPSIS +.B "int" nvme_dump_config +.BI "(nvme_root_t r " ");" +.SH ARGUMENTS +.IP "r" 12 +nvme_root_t object +.SH "DESCRIPTION" +Prints the current contents of the JSON configuration +file to stdout. +.SH "RETURN" +0 on success, -1 on failure. diff --git a/doc/man/nvme_dump_tree.2 b/doc/man/nvme_dump_tree.2 new file mode 100644 index 0000000..505f94c --- /dev/null +++ b/doc/man/nvme_dump_tree.2 @@ -0,0 +1,14 @@ +.TH "nvme_dump_tree" 9 "nvme_dump_tree" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_dump_tree \- Dump internal object tree +.SH SYNOPSIS +.B "int" nvme_dump_tree +.BI "(nvme_root_t r " ");" +.SH ARGUMENTS +.IP "r" 12 +nvme_root_t object +.SH "DESCRIPTION" +Prints the internal object tree in JSON format +to stdout. +.SH "RETURN" +0 on success, -1 on failure. diff --git a/doc/man/nvme_eg_critical_warning_flags.2 b/doc/man/nvme_eg_critical_warning_flags.2 new file mode 100644 index 0000000..ec2a3ff --- /dev/null +++ b/doc/man/nvme_eg_critical_warning_flags.2 @@ -0,0 +1,21 @@ +.TH "libnvme" 9 "enum nvme_eg_critical_warning_flags" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_eg_critical_warning_flags \- +.SH SYNOPSIS +enum nvme_eg_critical_warning_flags { +.br +.BI " NVME_EG_CRITICAL_WARNING_SPARE" +, +.br +.br +.BI " NVME_EG_CRITICAL_WARNING_DEGRADED" +, +.br +.br +.BI " NVME_EG_CRITICAL_WARNING_READ_ONLY" + +}; +.SH Constants +.IP "NVME_EG_CRITICAL_WARNING_SPARE" 12 +.IP "NVME_EG_CRITICAL_WARNING_DEGRADED" 12 +.IP "NVME_EG_CRITICAL_WARNING_READ_ONLY" 12 diff --git a/doc/man/nvme_eg_event_aggregate_log.2 b/doc/man/nvme_eg_event_aggregate_log.2 new file mode 100644 index 0000000..0546d53 --- /dev/null +++ b/doc/man/nvme_eg_event_aggregate_log.2 @@ -0,0 +1,19 @@ +.TH "libnvme" 9 "struct nvme_eg_event_aggregate_log" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_eg_event_aggregate_log \- +.SH SYNOPSIS +struct nvme_eg_event_aggregate_log { +.br +.BI " __le64 nr_entries;" +.br +.BI " __le16 egids[];" +.br +.BI " +}; +.br + +.SH Members +.IP "nr_entries" 12 +Number of Entries +.IP "egids" 12 +Endurance Group Identifier diff --git a/doc/man/nvme_end_grp_chan_desc.2 b/doc/man/nvme_end_grp_chan_desc.2 new file mode 100644 index 0000000..a7a810f --- /dev/null +++ b/doc/man/nvme_end_grp_chan_desc.2 @@ -0,0 +1,20 @@ +.TH "libnvme" 9 "struct nvme_end_grp_chan_desc" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_end_grp_chan_desc \- +.SH SYNOPSIS +struct nvme_end_grp_chan_desc { +.br +.BI " __le16 egchans;" +.br +.BI " struct nvme_channel_config_desc chan_config_desc[];" +.br +.BI " +}; +.br + +.SH Members +.IP "egchans" 12 +Number of Channels +.SH "Description" +Endurance group Channel Configuration Descriptor +Structure Definitions diff --git a/doc/man/nvme_end_grp_config_desc.2 b/doc/man/nvme_end_grp_config_desc.2 new file mode 100644 index 0000000..b418522 --- /dev/null +++ b/doc/man/nvme_end_grp_config_desc.2 @@ -0,0 +1,46 @@ +.TH "libnvme" 9 "struct nvme_end_grp_config_desc" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_end_grp_config_desc \- +.SH SYNOPSIS +struct nvme_end_grp_config_desc { +.br +.BI " __le16 endgid;" +.br +.BI " __le16 cap_adj_factor;" +.br +.BI " __u8 rsvd4[12];" +.br +.BI " __u8 tegcap[16];" +.br +.BI " __u8 segcap[16];" +.br +.BI " __u8 end_est[16];" +.br +.BI " __u8 rsvd64[16];" +.br +.BI " __le16 egsets;" +.br +.BI " __le16 nvmsetid[];" +.br +.BI " +}; +.br + +.SH Members +.IP "endgid" 12 +Endurance Group Identifier +.IP "cap_adj_factor" 12 +Capacity Adjustment Factor +.IP "tegcap" 12 +Total Endurance Group Capacity +.IP "segcap" 12 +Spare Endurance Group Capacity +.IP "end_est" 12 +Endurance Estimate +.IP "egsets" 12 +Number of NVM Sets +.IP "nvmsetid" 12 +NVM Set Identifier +.SH "Description" +Endurance Group Configuration Descriptor +Structure Definitions diff --git a/doc/man/nvme_endurance_group_log.2 b/doc/man/nvme_endurance_group_log.2 new file mode 100644 index 0000000..1ba728f --- /dev/null +++ b/doc/man/nvme_endurance_group_log.2 @@ -0,0 +1,71 @@ +.TH "libnvme" 9 "struct nvme_endurance_group_log" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_endurance_group_log \- +.SH SYNOPSIS +struct nvme_endurance_group_log { +.br +.BI " __u8 critical_warning;" +.br +.BI " __u8 rsvd1[2];" +.br +.BI " __u8 avl_spare;" +.br +.BI " __u8 avl_spare_threshold;" +.br +.BI " __u8 percent_used;" +.br +.BI " __u8 rsvd6[26];" +.br +.BI " __u8 endurance_estimate[16];" +.br +.BI " __u8 data_units_read[16];" +.br +.BI " __u8 data_units_written[16];" +.br +.BI " __u8 media_units_written[16];" +.br +.BI " __u8 host_read_cmds[16];" +.br +.BI " __u8 host_write_cmds[16];" +.br +.BI " __u8 media_data_integrity_err[16];" +.br +.BI " __u8 num_err_info_log_entries[16];" +.br +.BI " __u8 rsvd160[352];" +.br +.BI " +}; +.br + +.SH Members +.IP "critical_warning" 12 +Critical Warning +.IP "rsvd1" 12 +Reserved +.IP "avl_spare" 12 +Available Spare +.IP "avl_spare_threshold" 12 +Available Spare Threshold +.IP "percent_used" 12 +Percentage Used +.IP "rsvd6" 12 +Reserved +.IP "endurance_estimate" 12 +Endurance Estimate +.IP "data_units_read" 12 +Data Units Read +.IP "data_units_written" 12 +Data Units Written +.IP "media_units_written" 12 +Media Units Written +.IP "host_read_cmds" 12 +Host Read Commands +.IP "host_write_cmds" 12 +Host Write Commands +.IP "media_data_integrity_err" 12 +Media and Data Integrity Errors +.IP "num_err_info_log_entries" 12 +Number of Error Information Log Entries +.IP "rsvd160" 12 +Reserved diff --git a/doc/man/nvme_err_pel.2 b/doc/man/nvme_err_pel.2 new file mode 100644 index 0000000..e217cf7 --- /dev/null +++ b/doc/man/nvme_err_pel.2 @@ -0,0 +1,16 @@ +.TH "libnvme" 9 "enum nvme_err_pel" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_err_pel \- +.SH SYNOPSIS +enum nvme_err_pel { +.br +.BI " NVME_ERR_PEL_BYTE_MASK" +, +.br +.br +.BI " NVME_ERR_PEL_BIT_MASK" + +}; +.SH Constants +.IP "NVME_ERR_PEL_BYTE_MASK" 12 +.IP "NVME_ERR_PEL_BIT_MASK" 12 diff --git a/doc/man/nvme_errno_to_string.2 b/doc/man/nvme_errno_to_string.2 new file mode 100644 index 0000000..6e8ea1c --- /dev/null +++ b/doc/man/nvme_errno_to_string.2 @@ -0,0 +1,11 @@ +.TH "nvme_errno_to_string" 9 "nvme_errno_to_string" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_errno_to_string \- Returns string describing nvme connect failures +.SH SYNOPSIS +.B "const char *" nvme_errno_to_string +.BI "(int err " ");" +.SH ARGUMENTS +.IP "err" 12 +Returned error code from \fBnvme_add_ctrl\fP +.SH "RETURN" +String representation of the nvme connect error codes diff --git a/doc/man/nvme_error_log_page.2 b/doc/man/nvme_error_log_page.2 new file mode 100644 index 0000000..f6a908c --- /dev/null +++ b/doc/man/nvme_error_log_page.2 @@ -0,0 +1,109 @@ +.TH "libnvme" 9 "struct nvme_error_log_page" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_error_log_page \- Error Information Log Entry (Log Identifier 01h) +.SH SYNOPSIS +struct nvme_error_log_page { +.br +.BI " __le64 error_count;" +.br +.BI " __le16 sqid;" +.br +.BI " __le16 cmdid;" +.br +.BI " __le16 status_field;" +.br +.BI " __le16 parm_error_location;" +.br +.BI " __le64 lba;" +.br +.BI " __le32 nsid;" +.br +.BI " __u8 vs;" +.br +.BI " __u8 trtype;" +.br +.BI " __u8 rsvd[2];" +.br +.BI " __le64 cs;" +.br +.BI " __le16 trtype_spec_info;" +.br +.BI " __u8 rsvd2[22];" +.br +.BI " +}; +.br + +.SH Members +.IP "error_count" 12 +Error Count: a 64-bit incrementing error count, +indicating a unique identifier for this error. The error +count starts at 1h, is incremented for each unique error +log entry, and is retained across power off conditions. +A value of 0h indicates an invalid entry; this value +is used when there are lost entries or when there are +fewer errors than the maximum number of entries the +controller supports. If the value of this field is +FFFFFFFFh, then the field shall be set to 1h when +incremented (i.e., rolls over to 1h). Prior to NVMe +1.4, processing of incrementing beyond FFFFFFFFh is +unspecified. +.IP "sqid" 12 +Submission Queue ID: indicates the Submission Queue +Identifier of the command that the error information is +associated with. If the error is not specific to +a particular command, then this field shall be set to +FFFFh. +.IP "cmdid" 12 +Command ID: indicates the Command Identifier of the +command that the error is associated with. If the error +is not specific to a particular command, then this field +shall be set to FFFFh. +.IP "status_field" 12 +Bits 15-1: Status Field: indicates the Status Field for +the command that completed. If the error is not specific +to a particular command, then this field reports the most +applicable status value. +Bit 0: Phase Tag: may indicate the Phase Tag posted for +the command. +.IP "parm_error_location" 12 +Parameter Error Location: indicates the byte and bit of +the command parameter that the error is associated with, +if applicable. If the parameter spans multiple bytes or +bits, then the location indicates the first byte and bit +of the parameter. +Bits 10-8: Bit in command that contained the error. +Valid values are 0 to 7. +Bits 7-0: Byte in command that contained the error. +Valid values are 0 to 63. +.IP "lba" 12 +LBA: This field indicates the first LBA that experienced +the error condition, if applicable. +.IP "nsid" 12 +Namespace: This field indicates the NSID of the namespace +that the error is associated with, if applicable. +.IP "vs" 12 +Vendor Specific Information Available: If there is +additional vendor specific error information available, +this field provides the log page identifier associated +with that page. A value of 0h indicates that no additional +information is available. Valid values are in the range +of 80h to FFh. +.IP "trtype" 12 +Transport Type (TRTYPE): indicates the Transport Type of +the transport associated with the error. The values in +this field are the same as the TRTYPE values in the +Discovery Log Page Entry. If the error is not transport +related, this field shall be cleared to 0h. If the error +is transport related, this field shall be set to the type +of the transport - see \fIenum nvme_trtype\fP. +.IP "rsvd" 12 +Reserved +.IP "cs" 12 +Command Specific Information: This field contains command +specific information. If used, the command definition +specifies the information returned. +.IP "trtype_spec_info" 12 +Transport Type Specific Information +.IP "rsvd2" 12 +Reserved diff --git a/doc/man/nvme_fabrics_config.2 b/doc/man/nvme_fabrics_config.2 new file mode 100644 index 0000000..f54377f --- /dev/null +++ b/doc/man/nvme_fabrics_config.2 @@ -0,0 +1,75 @@ +.TH "libnvme" 9 "struct nvme_fabrics_config" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_fabrics_config \- Defines all linux nvme fabrics initiator options +.SH SYNOPSIS +struct nvme_fabrics_config { +.br +.BI " char *host_traddr;" +.br +.BI " char *host_iface;" +.br +.BI " int queue_size;" +.br +.BI " int nr_io_queues;" +.br +.BI " int reconnect_delay;" +.br +.BI " int ctrl_loss_tmo;" +.br +.BI " int fast_io_fail_tmo;" +.br +.BI " int keep_alive_tmo;" +.br +.BI " int nr_write_queues;" +.br +.BI " int nr_poll_queues;" +.br +.BI " int tos;" +.br +.BI " bool duplicate_connect;" +.br +.BI " bool disable_sqflow;" +.br +.BI " bool hdr_digest;" +.br +.BI " bool data_digest;" +.br +.BI " bool tls;" +.br +.BI " +}; +.br + +.SH Members +.IP "host_traddr" 12 +Host transport address +.IP "host_iface" 12 +Host interface name +.IP "queue_size" 12 +Number of IO queue entries +.IP "nr_io_queues" 12 +Number of controller IO queues to establish +.IP "reconnect_delay" 12 +Time between two consecutive reconnect attempts. +.IP "ctrl_loss_tmo" 12 +Override the default controller reconnect attempt timeout in seconds +.IP "fast_io_fail_tmo" 12 +Set the fast I/O fail timeout in seconds. +.IP "keep_alive_tmo" 12 +Override the default keep-alive-timeout to this value in seconds +.IP "nr_write_queues" 12 +Number of queues to use for exclusively for writing +.IP "nr_poll_queues" 12 +Number of queues to reserve for polling completions +.IP "tos" 12 +Type of service +.IP "duplicate_connect" 12 +Allow multiple connections to the same target +.IP "disable_sqflow" 12 +Disable controller sq flow control +.IP "hdr_digest" 12 +Generate/verify header digest (TCP) +.IP "data_digest" 12 +Generate/verify data digest (TCP) +.IP "tls" 12 +Start TLS on the connection (TCP) diff --git a/doc/man/nvme_fctype.2 b/doc/man/nvme_fctype.2 new file mode 100644 index 0000000..560a989 --- /dev/null +++ b/doc/man/nvme_fctype.2 @@ -0,0 +1,42 @@ +.TH "libnvme" 9 "enum nvme_fctype" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_fctype \- +.SH SYNOPSIS +enum nvme_fctype { +.br +.BI " nvme_fabrics_type_property_set" +, +.br +.br +.BI " nvme_fabrics_type_connect" +, +.br +.br +.BI " nvme_fabrics_type_property_get" +, +.br +.br +.BI " nvme_fabrics_type_auth_send" +, +.br +.br +.BI " nvme_fabrics_type_auth_receive" +, +.br +.br +.BI " nvme_fabrics_type_disconnect" + +}; +.SH Constants +.IP "nvme_fabrics_type_property_set" 12 +Property set +.IP "nvme_fabrics_type_connect" 12 +Connect +.IP "nvme_fabrics_type_property_get" 12 +Property Get +.IP "nvme_fabrics_type_auth_send" 12 +Authentication Send +.IP "nvme_fabrics_type_auth_receive" 12 +Authentication Receive +.IP "nvme_fabrics_type_disconnect" 12 +Disconnect diff --git a/doc/man/nvme_feat.2 b/doc/man/nvme_feat.2 new file mode 100644 index 0000000..981cd62 --- /dev/null +++ b/doc/man/nvme_feat.2 @@ -0,0 +1,496 @@ +.TH "libnvme" 9 "enum nvme_feat" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_feat \- +.SH SYNOPSIS +enum nvme_feat { +.br +.BI " NVME_FEAT_ARBITRATION_BURST_SHIFT" +, +.br +.br +.BI " NVME_FEAT_ARBITRATION_BURST_MASK" +, +.br +.br +.BI " NVME_FEAT_ARBITRATION_LPW_SHIFT" +, +.br +.br +.BI " NVME_FEAT_ARBITRATION_LPW_MASK" +, +.br +.br +.BI " NVME_FEAT_ARBITRATION_MPW_SHIFT" +, +.br +.br +.BI " NVME_FEAT_ARBITRATION_MPW_MASK" +, +.br +.br +.BI " NVME_FEAT_ARBITRATION_HPW_SHIFT" +, +.br +.br +.BI " NVME_FEAT_ARBITRATION_HPW_MASK" +, +.br +.br +.BI " NVME_FEAT_PWRMGMT_PS_SHIFT" +, +.br +.br +.BI " NVME_FEAT_PWRMGMT_PS_MASK" +, +.br +.br +.BI " NVME_FEAT_PWRMGMT_WH_SHIFT" +, +.br +.br +.BI " NVME_FEAT_PWRMGMT_WH_MASK" +, +.br +.br +.BI " NVME_FEAT_LBAR_NR_SHIFT" +, +.br +.br +.BI " NVME_FEAT_LBAR_NR_MASK" +, +.br +.br +.BI " NVME_FEAT_TT_TMPTH_SHIFT" +, +.br +.br +.BI " NVME_FEAT_TT_TMPTH_MASK" +, +.br +.br +.BI " NVME_FEAT_TT_TMPSEL_SHIFT" +, +.br +.br +.BI " NVME_FEAT_TT_TMPSEL_MASK" +, +.br +.br +.BI " NVME_FEAT_TT_THSEL_SHIFT" +, +.br +.br +.BI " NVME_FEAT_TT_THSEL_MASK" +, +.br +.br +.BI " NVME_FEAT_ERROR_RECOVERY_TLER_SHIFT" +, +.br +.br +.BI " NVME_FEAT_ERROR_RECOVERY_TLER_MASK" +, +.br +.br +.BI " NVME_FEAT_ERROR_RECOVERY_DULBE_SHIFT" +, +.br +.br +.BI " NVME_FEAT_ERROR_RECOVERY_DULBE_MASK" +, +.br +.br +.BI " NVME_FEAT_VWC_WCE_SHIFT" +, +.br +.br +.BI " NVME_FEAT_VWC_WCE_MASK" +, +.br +.br +.BI " NVME_FEAT_NRQS_NSQR_SHIFT" +, +.br +.br +.BI " NVME_FEAT_NRQS_NSQR_MASK" +, +.br +.br +.BI " NVME_FEAT_NRQS_NCQR_SHIFT" +, +.br +.br +.BI " NVME_FEAT_NRQS_NCQR_MASK" +, +.br +.br +.BI " NVME_FEAT_IRQC_THR_SHIFT" +, +.br +.br +.BI " NVME_FEAT_IRQC_THR_MASK" +, +.br +.br +.BI " NVME_FEAT_IRQC_TIME_SHIFT" +, +.br +.br +.BI " NVME_FEAT_IRQC_TIME_MASK" +, +.br +.br +.BI " NVME_FEAT_ICFG_IV_SHIFT" +, +.br +.br +.BI " NVME_FEAT_ICFG_IV_MASK" +, +.br +.br +.BI " NVME_FEAT_ICFG_CD_SHIFT" +, +.br +.br +.BI " NVME_FEAT_ICFG_CD_MASK" +, +.br +.br +.BI " NVME_FEAT_WA_DN_SHIFT" +, +.br +.br +.BI " NVME_FEAT_WA_DN_MASK" +, +.br +.br +.BI " NVME_FEAT_AE_SMART_SHIFT" +, +.br +.br +.BI " NVME_FEAT_AE_SMART_MASK" +, +.br +.br +.BI " NVME_FEAT_AE_NAN_SHIFT" +, +.br +.br +.BI " NVME_FEAT_AE_NAN_MASK" +, +.br +.br +.BI " NVME_FEAT_AE_FW_SHIFT" +, +.br +.br +.BI " NVME_FEAT_AE_FW_MASK" +, +.br +.br +.BI " NVME_FEAT_AE_TELEM_SHIFT" +, +.br +.br +.BI " NVME_FEAT_AE_TELEM_MASK" +, +.br +.br +.BI " NVME_FEAT_AE_ANA_SHIFT" +, +.br +.br +.BI " NVME_FEAT_AE_ANA_MASK" +, +.br +.br +.BI " NVME_FEAT_AE_PLA_SHIFT" +, +.br +.br +.BI " NVME_FEAT_AE_PLA_MASK" +, +.br +.br +.BI " NVME_FEAT_AE_LBAS_SHIFT" +, +.br +.br +.BI " NVME_FEAT_AE_LBAS_MASK" +, +.br +.br +.BI " NVME_FEAT_AE_EGA_SHIFT" +, +.br +.br +.BI " NVME_FEAT_AE_EGA_MASK" +, +.br +.br +.BI " NVME_FEAT_APST_APSTE_SHIFT" +, +.br +.br +.BI " NVME_FEAT_APST_APSTE_MASK" +, +.br +.br +.BI " NVME_FEAT_HMEM_EHM_SHIFT" +, +.br +.br +.BI " NVME_FEAT_HMEM_EHM_MASK" +, +.br +.br +.BI " NVME_FEAT_HCTM_TMT2_SHIFT" +, +.br +.br +.BI " NVME_FEAT_HCTM_TMT2_MASK" +, +.br +.br +.BI " NVME_FEAT_HCTM_TMT1_SHIFT" +, +.br +.br +.BI " NVME_FEAT_HCTM_TMT1_MASK" +, +.br +.br +.BI " NVME_FEAT_NOPS_NOPPME_SHIFT" +, +.br +.br +.BI " NVME_FEAT_NOPS_NOPPME_MASK" +, +.br +.br +.BI " NVME_FEAT_RRL_RRL_SHIFT" +, +.br +.br +.BI " NVME_FEAT_RRL_RRL_MASK" +, +.br +.br +.BI " NVME_FEAT_PLM_PLME_SHIFT" +, +.br +.br +.BI " NVME_FEAT_PLM_PLME_MASK" +, +.br +.br +.BI " NVME_FEAT_PLMW_WS_SHIFT" +, +.br +.br +.BI " NVME_FEAT_PLMW_WS_MASK" +, +.br +.br +.BI " NVME_FEAT_LBAS_LSIRI_SHIFT" +, +.br +.br +.BI " NVME_FEAT_LBAS_LSIRI_MASK" +, +.br +.br +.BI " NVME_FEAT_LBAS_LSIPI_SHIFT" +, +.br +.br +.BI " NVME_FEAT_LBAS_LSIPI_MASK" +, +.br +.br +.BI " NVME_FEAT_SC_NODRM_SHIFT" +, +.br +.br +.BI " NVME_FEAT_SC_NODRM_MASK" +, +.br +.br +.BI " NVME_FEAT_EG_ENDGID_SHIFT" +, +.br +.br +.BI " NVME_FEAT_EG_ENDGID_MASK" +, +.br +.br +.BI " NVME_FEAT_EG_EGCW_SHIFT" +, +.br +.br +.BI " NVME_FEAT_EG_EGCW_MASK" +, +.br +.br +.BI " NVME_FEAT_SPM_PBSLC_SHIFT" +, +.br +.br +.BI " NVME_FEAT_SPM_PBSLC_MASK" +, +.br +.br +.BI " NVME_FEAT_HOSTID_EXHID_SHIFT" +, +.br +.br +.BI " NVME_FEAT_HOSTID_EXHID_MASK" +, +.br +.br +.BI " NVME_FEAT_RM_REGPRE_SHIFT" +, +.br +.br +.BI " NVME_FEAT_RM_REGPRE_MASK" +, +.br +.br +.BI " NVME_FEAT_RM_RESREL_SHIFT" +, +.br +.br +.BI " NVME_FEAT_RM_RESREL_MASK" +, +.br +.br +.BI " NVME_FEAT_RM_RESPRE_SHIFT" +, +.br +.br +.BI " NVME_FEAT_RM_RESPRE_MASK" +, +.br +.br +.BI " NVME_FEAT_RP_PTPL_SHIFT" +, +.br +.br +.BI " NVME_FEAT_RP_PTPL_MASK" +, +.br +.br +.BI " NVME_FEAT_WP_WPS_SHIFT" +, +.br +.br +.BI " NVME_FEAT_WP_WPS_MASK" +, +.br +.br +.BI " NVME_FEAT_IOCSP_IOCSCI_SHIFT" +, +.br +.br +.BI " NVME_FEAT_IOCSP_IOCSCI_MASK" + +}; +.SH Constants +.IP "NVME_FEAT_ARBITRATION_BURST_SHIFT" 12 +.IP "NVME_FEAT_ARBITRATION_BURST_MASK" 12 +.IP "NVME_FEAT_ARBITRATION_LPW_SHIFT" 12 +.IP "NVME_FEAT_ARBITRATION_LPW_MASK" 12 +.IP "NVME_FEAT_ARBITRATION_MPW_SHIFT" 12 +.IP "NVME_FEAT_ARBITRATION_MPW_MASK" 12 +.IP "NVME_FEAT_ARBITRATION_HPW_SHIFT" 12 +.IP "NVME_FEAT_ARBITRATION_HPW_MASK" 12 +.IP "NVME_FEAT_PWRMGMT_PS_SHIFT" 12 +.IP "NVME_FEAT_PWRMGMT_PS_MASK" 12 +.IP "NVME_FEAT_PWRMGMT_WH_SHIFT" 12 +.IP "NVME_FEAT_PWRMGMT_WH_MASK" 12 +.IP "NVME_FEAT_LBAR_NR_SHIFT" 12 +.IP "NVME_FEAT_LBAR_NR_MASK" 12 +.IP "NVME_FEAT_TT_TMPTH_SHIFT" 12 +.IP "NVME_FEAT_TT_TMPTH_MASK" 12 +.IP "NVME_FEAT_TT_TMPSEL_SHIFT" 12 +.IP "NVME_FEAT_TT_TMPSEL_MASK" 12 +.IP "NVME_FEAT_TT_THSEL_SHIFT" 12 +.IP "NVME_FEAT_TT_THSEL_MASK" 12 +.IP "NVME_FEAT_ERROR_RECOVERY_TLER_SHIFT" 12 +.IP "NVME_FEAT_ERROR_RECOVERY_TLER_MASK" 12 +.IP "NVME_FEAT_ERROR_RECOVERY_DULBE_SHIFT" 12 +.IP "NVME_FEAT_ERROR_RECOVERY_DULBE_MASK" 12 +.IP "NVME_FEAT_VWC_WCE_SHIFT" 12 +.IP "NVME_FEAT_VWC_WCE_MASK" 12 +.IP "NVME_FEAT_NRQS_NSQR_SHIFT" 12 +.IP "NVME_FEAT_NRQS_NSQR_MASK" 12 +.IP "NVME_FEAT_NRQS_NCQR_SHIFT" 12 +.IP "NVME_FEAT_NRQS_NCQR_MASK" 12 +.IP "NVME_FEAT_IRQC_THR_SHIFT" 12 +.IP "NVME_FEAT_IRQC_THR_MASK" 12 +.IP "NVME_FEAT_IRQC_TIME_SHIFT" 12 +.IP "NVME_FEAT_IRQC_TIME_MASK" 12 +.IP "NVME_FEAT_ICFG_IV_SHIFT" 12 +.IP "NVME_FEAT_ICFG_IV_MASK" 12 +.IP "NVME_FEAT_ICFG_CD_SHIFT" 12 +.IP "NVME_FEAT_ICFG_CD_MASK" 12 +.IP "NVME_FEAT_WA_DN_SHIFT" 12 +.IP "NVME_FEAT_WA_DN_MASK" 12 +.IP "NVME_FEAT_AE_SMART_SHIFT" 12 +.IP "NVME_FEAT_AE_SMART_MASK" 12 +.IP "NVME_FEAT_AE_NAN_SHIFT" 12 +.IP "NVME_FEAT_AE_NAN_MASK" 12 +.IP "NVME_FEAT_AE_FW_SHIFT" 12 +.IP "NVME_FEAT_AE_FW_MASK" 12 +.IP "NVME_FEAT_AE_TELEM_SHIFT" 12 +.IP "NVME_FEAT_AE_TELEM_MASK" 12 +.IP "NVME_FEAT_AE_ANA_SHIFT" 12 +.IP "NVME_FEAT_AE_ANA_MASK" 12 +.IP "NVME_FEAT_AE_PLA_SHIFT" 12 +.IP "NVME_FEAT_AE_PLA_MASK" 12 +.IP "NVME_FEAT_AE_LBAS_SHIFT" 12 +.IP "NVME_FEAT_AE_LBAS_MASK" 12 +.IP "NVME_FEAT_AE_EGA_SHIFT" 12 +.IP "NVME_FEAT_AE_EGA_MASK" 12 +.IP "NVME_FEAT_APST_APSTE_SHIFT" 12 +.IP "NVME_FEAT_APST_APSTE_MASK" 12 +.IP "NVME_FEAT_HMEM_EHM_SHIFT" 12 +.IP "NVME_FEAT_HMEM_EHM_MASK" 12 +.IP "NVME_FEAT_HCTM_TMT2_SHIFT" 12 +.IP "NVME_FEAT_HCTM_TMT2_MASK" 12 +.IP "NVME_FEAT_HCTM_TMT1_SHIFT" 12 +.IP "NVME_FEAT_HCTM_TMT1_MASK" 12 +.IP "NVME_FEAT_NOPS_NOPPME_SHIFT" 12 +.IP "NVME_FEAT_NOPS_NOPPME_MASK" 12 +.IP "NVME_FEAT_RRL_RRL_SHIFT" 12 +.IP "NVME_FEAT_RRL_RRL_MASK" 12 +.IP "NVME_FEAT_PLM_PLME_SHIFT" 12 +.IP "NVME_FEAT_PLM_PLME_MASK" 12 +.IP "NVME_FEAT_PLMW_WS_SHIFT" 12 +.IP "NVME_FEAT_PLMW_WS_MASK" 12 +.IP "NVME_FEAT_LBAS_LSIRI_SHIFT" 12 +.IP "NVME_FEAT_LBAS_LSIRI_MASK" 12 +.IP "NVME_FEAT_LBAS_LSIPI_SHIFT" 12 +.IP "NVME_FEAT_LBAS_LSIPI_MASK" 12 +.IP "NVME_FEAT_SC_NODRM_SHIFT" 12 +.IP "NVME_FEAT_SC_NODRM_MASK" 12 +.IP "NVME_FEAT_EG_ENDGID_SHIFT" 12 +.IP "NVME_FEAT_EG_ENDGID_MASK" 12 +.IP "NVME_FEAT_EG_EGCW_SHIFT" 12 +.IP "NVME_FEAT_EG_EGCW_MASK" 12 +.IP "NVME_FEAT_SPM_PBSLC_SHIFT" 12 +.IP "NVME_FEAT_SPM_PBSLC_MASK" 12 +.IP "NVME_FEAT_HOSTID_EXHID_SHIFT" 12 +.IP "NVME_FEAT_HOSTID_EXHID_MASK" 12 +.IP "NVME_FEAT_RM_REGPRE_SHIFT" 12 +.IP "NVME_FEAT_RM_REGPRE_MASK" 12 +.IP "NVME_FEAT_RM_RESREL_SHIFT" 12 +.IP "NVME_FEAT_RM_RESREL_MASK" 12 +.IP "NVME_FEAT_RM_RESPRE_SHIFT" 12 +.IP "NVME_FEAT_RM_RESPRE_MASK" 12 +.IP "NVME_FEAT_RP_PTPL_SHIFT" 12 +.IP "NVME_FEAT_RP_PTPL_MASK" 12 +.IP "NVME_FEAT_WP_WPS_SHIFT" 12 +.IP "NVME_FEAT_WP_WPS_MASK" 12 +.IP "NVME_FEAT_IOCSP_IOCSCI_SHIFT" 12 +.IP "NVME_FEAT_IOCSP_IOCSCI_MASK" 12 diff --git a/doc/man/nvme_feat_auto_pst.2 b/doc/man/nvme_feat_auto_pst.2 new file mode 100644 index 0000000..c84f481 --- /dev/null +++ b/doc/man/nvme_feat_auto_pst.2 @@ -0,0 +1,15 @@ +.TH "libnvme" 9 "struct nvme_feat_auto_pst" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_feat_auto_pst \- +.SH SYNOPSIS +struct nvme_feat_auto_pst { +.br +.BI " __le64 apst_entry[32];" +.br +.BI " +}; +.br + +.SH Members +.IP "apst_entry" 12 +See \fIenum nvme_apst_entry\fP diff --git a/doc/man/nvme_feat_host_behavior.2 b/doc/man/nvme_feat_host_behavior.2 new file mode 100644 index 0000000..7f9be77 --- /dev/null +++ b/doc/man/nvme_feat_host_behavior.2 @@ -0,0 +1,19 @@ +.TH "libnvme" 9 "struct nvme_feat_host_behavior" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_feat_host_behavior \- +.SH SYNOPSIS +struct nvme_feat_host_behavior { +.br +.BI " __u8 acre;" +.br +.BI " __u8 rsvd1[511];" +.br +.BI " +}; +.br + +.SH Members +.IP "acre" 12 +Advanced Command Retry Enable +.IP "rsvd1" 12 +Reserved diff --git a/doc/man/nvme_feat_nswpcfg_state.2 b/doc/man/nvme_feat_nswpcfg_state.2 new file mode 100644 index 0000000..c671e63 --- /dev/null +++ b/doc/man/nvme_feat_nswpcfg_state.2 @@ -0,0 +1,30 @@ +.TH "libnvme" 9 "enum nvme_feat_nswpcfg_state" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_feat_nswpcfg_state \- +.SH SYNOPSIS +enum nvme_feat_nswpcfg_state { +.br +.BI " NVME_FEAT_NS_NO_WRITE_PROTECT" +, +.br +.br +.BI " NVME_FEAT_NS_WRITE_PROTECT" +, +.br +.br +.BI " NVME_FEAT_NS_WRITE_PROTECT_PWR_CYCLE" +, +.br +.br +.BI " NVME_FEAT_NS_WRITE_PROTECT_PERMANENT" + +}; +.SH Constants +.IP "NVME_FEAT_NS_NO_WRITE_PROTECT" 12 +No Write Protect +.IP "NVME_FEAT_NS_WRITE_PROTECT" 12 +Write Protect +.IP "NVME_FEAT_NS_WRITE_PROTECT_PWR_CYCLE" 12 +Write Protect Until Power Cycle +.IP "NVME_FEAT_NS_WRITE_PROTECT_PERMANENT" 12 +Permanent Write Protect diff --git a/doc/man/nvme_feat_plm_window_select.2 b/doc/man/nvme_feat_plm_window_select.2 new file mode 100644 index 0000000..a864d98 --- /dev/null +++ b/doc/man/nvme_feat_plm_window_select.2 @@ -0,0 +1,18 @@ +.TH "libnvme" 9 "enum nvme_feat_plm_window_select" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_feat_plm_window_select \- +.SH SYNOPSIS +enum nvme_feat_plm_window_select { +.br +.BI " NVME_FEATURE_PLM_DTWIN" +, +.br +.br +.BI " NVME_FEATURE_PLM_NDWIN" + +}; +.SH Constants +.IP "NVME_FEATURE_PLM_DTWIN" 12 +Deterministic Window select +.IP "NVME_FEATURE_PLM_NDWIN" 12 +Non-Deterministic Window select diff --git a/doc/man/nvme_feat_resv_notify_flags.2 b/doc/man/nvme_feat_resv_notify_flags.2 new file mode 100644 index 0000000..53a262b --- /dev/null +++ b/doc/man/nvme_feat_resv_notify_flags.2 @@ -0,0 +1,24 @@ +.TH "libnvme" 9 "enum nvme_feat_resv_notify_flags" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_feat_resv_notify_flags \- +.SH SYNOPSIS +enum nvme_feat_resv_notify_flags { +.br +.BI " NVME_FEAT_RESV_NOTIFY_REGPRE" +, +.br +.br +.BI " NVME_FEAT_RESV_NOTIFY_RESREL" +, +.br +.br +.BI " NVME_FEAT_RESV_NOTIFY_RESPRE" + +}; +.SH Constants +.IP "NVME_FEAT_RESV_NOTIFY_REGPRE" 12 +Mask Registration Preempted Notification +.IP "NVME_FEAT_RESV_NOTIFY_RESREL" 12 +Mask Reservation Released Notification +.IP "NVME_FEAT_RESV_NOTIFY_RESPRE" 12 +Mask Reservation Preempted Notification diff --git a/doc/man/nvme_feat_tmpthresh_thsel.2 b/doc/man/nvme_feat_tmpthresh_thsel.2 new file mode 100644 index 0000000..1c91429 --- /dev/null +++ b/doc/man/nvme_feat_tmpthresh_thsel.2 @@ -0,0 +1,18 @@ +.TH "libnvme" 9 "enum nvme_feat_tmpthresh_thsel" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_feat_tmpthresh_thsel \- +.SH SYNOPSIS +enum nvme_feat_tmpthresh_thsel { +.br +.BI " NVME_FEATURE_TEMPTHRESH_THSEL_OVER" +, +.br +.br +.BI " NVME_FEATURE_TEMPTHRESH_THSEL_UNDER" + +}; +.SH Constants +.IP "NVME_FEATURE_TEMPTHRESH_THSEL_OVER" 12 +Over temperature threshold select +.IP "NVME_FEATURE_TEMPTHRESH_THSEL_UNDER" 12 +Under temperature threshold select diff --git a/doc/man/nvme_features_async_event_config_flags.2 b/doc/man/nvme_features_async_event_config_flags.2 new file mode 100644 index 0000000..eaa5062 --- /dev/null +++ b/doc/man/nvme_features_async_event_config_flags.2 @@ -0,0 +1,76 @@ +.TH "libnvme" 9 "enum nvme_features_async_event_config_flags" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_features_async_event_config_flags \- +.SH SYNOPSIS +enum nvme_features_async_event_config_flags { +.br +.BI " NVME_FEATURE_AENCFG_SMART_CRIT_SPARE" +, +.br +.br +.BI " NVME_FEATURE_AENCFG_SMART_CRIT_TEMPERATURE" +, +.br +.br +.BI " NVME_FEATURE_AENCFG_SMART_CRIT_DEGRADED" +, +.br +.br +.BI " NVME_FEATURE_AENCFG_SMART_CRIT_READ_ONLY" +, +.br +.br +.BI " NVME_FEATURE_AENCFG_SMART_CRIT_VOLATILE_BACKUP" +, +.br +.br +.BI " NVME_FEATURE_AENCFG_SMART_CRIT_READ_ONLY_PMR" +, +.br +.br +.BI " NVME_FEATURE_AENCFG_NOTICE_NAMESPACE_ATTRIBUTES" +, +.br +.br +.BI " NVME_FEATURE_AENCFG_NOTICE_FIRMWARE_ACTIVATION" +, +.br +.br +.BI " NVME_FEATURE_AENCFG_NOTICE_TELEMETRY_LOG" +, +.br +.br +.BI " NVME_FEATURE_AENCFG_NOTICE_ANA_CHANGE" +, +.br +.br +.BI " NVME_FEATURE_AENCFG_NOTICE_PL_EVENT" +, +.br +.br +.BI " NVME_FEATURE_AENCFG_NOTICE_LBA_STATUS" +, +.br +.br +.BI " NVME_FEATURE_AENCFG_NOTICE_EG_EVENT" +, +.br +.br +.BI " NVME_FEATURE_AENCFG_NOTICE_DISCOVERY_CHANGE" + +}; +.SH Constants +.IP "NVME_FEATURE_AENCFG_SMART_CRIT_SPARE" 12 +.IP "NVME_FEATURE_AENCFG_SMART_CRIT_TEMPERATURE" 12 +.IP "NVME_FEATURE_AENCFG_SMART_CRIT_DEGRADED" 12 +.IP "NVME_FEATURE_AENCFG_SMART_CRIT_READ_ONLY" 12 +.IP "NVME_FEATURE_AENCFG_SMART_CRIT_VOLATILE_BACKUP" 12 +.IP "NVME_FEATURE_AENCFG_SMART_CRIT_READ_ONLY_PMR" 12 +.IP "NVME_FEATURE_AENCFG_NOTICE_NAMESPACE_ATTRIBUTES" 12 +.IP "NVME_FEATURE_AENCFG_NOTICE_FIRMWARE_ACTIVATION" 12 +.IP "NVME_FEATURE_AENCFG_NOTICE_TELEMETRY_LOG" 12 +.IP "NVME_FEATURE_AENCFG_NOTICE_ANA_CHANGE" 12 +.IP "NVME_FEATURE_AENCFG_NOTICE_PL_EVENT" 12 +.IP "NVME_FEATURE_AENCFG_NOTICE_LBA_STATUS" 12 +.IP "NVME_FEATURE_AENCFG_NOTICE_EG_EVENT" 12 +.IP "NVME_FEATURE_AENCFG_NOTICE_DISCOVERY_CHANGE" 12 diff --git a/doc/man/nvme_features_id.2 b/doc/man/nvme_features_id.2 new file mode 100644 index 0000000..a908964 --- /dev/null +++ b/doc/man/nvme_features_id.2 @@ -0,0 +1,210 @@ +.TH "libnvme" 9 "enum nvme_features_id" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_features_id \- +.SH SYNOPSIS +enum nvme_features_id { +.br +.BI " NVME_FEAT_FID_ARBITRATION" +, +.br +.br +.BI " NVME_FEAT_FID_POWER_MGMT" +, +.br +.br +.BI " NVME_FEAT_FID_LBA_RANGE" +, +.br +.br +.BI " NVME_FEAT_FID_TEMP_THRESH" +, +.br +.br +.BI " NVME_FEAT_FID_ERR_RECOVERY" +, +.br +.br +.BI " NVME_FEAT_FID_VOLATILE_WC" +, +.br +.br +.BI " NVME_FEAT_FID_NUM_QUEUES" +, +.br +.br +.BI " NVME_FEAT_FID_IRQ_COALESCE" +, +.br +.br +.BI " NVME_FEAT_FID_IRQ_CONFIG" +, +.br +.br +.BI " NVME_FEAT_FID_WRITE_ATOMIC" +, +.br +.br +.BI " NVME_FEAT_FID_ASYNC_EVENT" +, +.br +.br +.BI " NVME_FEAT_FID_AUTO_PST" +, +.br +.br +.BI " NVME_FEAT_FID_HOST_MEM_BUF" +, +.br +.br +.BI " NVME_FEAT_FID_TIMESTAMP" +, +.br +.br +.BI " NVME_FEAT_FID_KATO" +, +.br +.br +.BI " NVME_FEAT_FID_HCTM" +, +.br +.br +.BI " NVME_FEAT_FID_NOPSC" +, +.br +.br +.BI " NVME_FEAT_FID_RRL" +, +.br +.br +.BI " NVME_FEAT_FID_PLM_CONFIG" +, +.br +.br +.BI " NVME_FEAT_FID_PLM_WINDOW" +, +.br +.br +.BI " NVME_FEAT_FID_LBA_STS_INTERVAL" +, +.br +.br +.BI " NVME_FEAT_FID_HOST_BEHAVIOR" +, +.br +.br +.BI " NVME_FEAT_FID_SANITIZE" +, +.br +.br +.BI " NVME_FEAT_FID_ENDURANCE_EVT_CFG" +, +.br +.br +.BI " NVME_FEAT_FID_IOCS_PROFILE" +, +.br +.br +.BI " NVME_FEAT_FID_SPINUP_CONTROL" +, +.br +.br +.BI " NVME_FEAT_FID_ENH_CTRL_METADATA" +, +.br +.br +.BI " NVME_FEAT_FID_CTRL_METADATA" +, +.br +.br +.BI " NVME_FEAT_FID_NS_METADATA" +, +.br +.br +.BI " NVME_FEAT_FID_SW_PROGRESS" +, +.br +.br +.BI " NVME_FEAT_FID_HOST_ID" +, +.br +.br +.BI " NVME_FEAT_FID_RESV_MASK" +, +.br +.br +.BI " NVME_FEAT_FID_RESV_PERSIST" +, +.br +.br +.BI " NVME_FEAT_FID_WRITE_PROTECT" + +}; +.SH Constants +.IP "NVME_FEAT_FID_ARBITRATION" 12 +Arbitration +.IP "NVME_FEAT_FID_POWER_MGMT" 12 +Power Management +.IP "NVME_FEAT_FID_LBA_RANGE" 12 +LBA Range Type +.IP "NVME_FEAT_FID_TEMP_THRESH" 12 +Temperature Threshold +.IP "NVME_FEAT_FID_ERR_RECOVERY" 12 +Error Recovery +.IP "NVME_FEAT_FID_VOLATILE_WC" 12 +Volatile Write Cache +.IP "NVME_FEAT_FID_NUM_QUEUES" 12 +Number of Queues +.IP "NVME_FEAT_FID_IRQ_COALESCE" 12 +Interrupt Coalescing +.IP "NVME_FEAT_FID_IRQ_CONFIG" 12 +Interrupt Vector Configuration +.IP "NVME_FEAT_FID_WRITE_ATOMIC" 12 +Write Atomicity Normal +.IP "NVME_FEAT_FID_ASYNC_EVENT" 12 +Asynchronous Event Configuration +.IP "NVME_FEAT_FID_AUTO_PST" 12 +Autonomous Power State Transition +.IP "NVME_FEAT_FID_HOST_MEM_BUF" 12 +Host Memory Buffer +.IP "NVME_FEAT_FID_TIMESTAMP" 12 +Timestamp +.IP "NVME_FEAT_FID_KATO" 12 +Keep Alive Timer +.IP "NVME_FEAT_FID_HCTM" 12 +Host Controlled Thermal Management +.IP "NVME_FEAT_FID_NOPSC" 12 +Non-Operational Power State Config +.IP "NVME_FEAT_FID_RRL" 12 +Read Recovery Level Config +.IP "NVME_FEAT_FID_PLM_CONFIG" 12 +Predictable Latency Mode Config +.IP "NVME_FEAT_FID_PLM_WINDOW" 12 +Predictable Latency Mode Window +.IP "NVME_FEAT_FID_LBA_STS_INTERVAL" 12 +LBA Status Information Report Interval +.IP "NVME_FEAT_FID_HOST_BEHAVIOR" 12 +Host Behavior Support +.IP "NVME_FEAT_FID_SANITIZE" 12 +Endurance Group Event Configuration +.IP "NVME_FEAT_FID_ENDURANCE_EVT_CFG" 12 +Endurance Group Event Configuration +.IP "NVME_FEAT_FID_IOCS_PROFILE" 12 +I/O Command Set Profile +.IP "NVME_FEAT_FID_SPINUP_CONTROL" 12 +Spinup Control +.IP "NVME_FEAT_FID_ENH_CTRL_METADATA" 12 +Enhanced Controller Metadata +.IP "NVME_FEAT_FID_CTRL_METADATA" 12 +Controller Metadata +.IP "NVME_FEAT_FID_NS_METADATA" 12 +Namespace Metadata +.IP "NVME_FEAT_FID_SW_PROGRESS" 12 +Software Progress Marker +.IP "NVME_FEAT_FID_HOST_ID" 12 +Host Identifier +.IP "NVME_FEAT_FID_RESV_MASK" 12 +Reservation Notification Mask +.IP "NVME_FEAT_FID_RESV_PERSIST" 12 +Reservation Persistence +.IP "NVME_FEAT_FID_WRITE_PROTECT" 12 +Namespace Write Protection Config diff --git a/doc/man/nvme_fid_supported_effects.2 b/doc/man/nvme_fid_supported_effects.2 new file mode 100644 index 0000000..353ed27 --- /dev/null +++ b/doc/man/nvme_fid_supported_effects.2 @@ -0,0 +1,78 @@ +.TH "libnvme" 9 "enum nvme_fid_supported_effects" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_fid_supported_effects \- +.SH SYNOPSIS +enum nvme_fid_supported_effects { +.br +.BI " NVME_FID_SUPPORTED_EFFECTS_FSUPP" +, +.br +.br +.BI " NVME_FID_SUPPORTED_EFFECTS_UDCC" +, +.br +.br +.BI " NVME_FID_SUPPORTED_EFFECTS_NCC" +, +.br +.br +.BI " NVME_FID_SUPPORTED_EFFECTS_NIC" +, +.br +.br +.BI " NVME_FID_SUPPORTED_EFFECTS_CCC" +, +.br +.br +.BI " NVME_FID_SUPPORTED_EFFECTS_UUID_SEL" +, +.br +.br +.BI " NVME_FID_SUPPORTED_EFFECTS_SCOPE_SHIFT" +, +.br +.br +.BI " NVME_FID_SUPPORTED_EFFECTS_SCOPE_MASK" +, +.br +.br +.BI " NVME_FID_SUPPORTED_EFFECTS_SCOPE_NS" +, +.br +.br +.BI " NVME_FID_SUPPORTED_EFFECTS_SCOPE_CTRL" +, +.br +.br +.BI " NVME_FID_SUPPORTED_EFFECTS_SCOPE_NVM_SET" +, +.br +.br +.BI " NVME_FID_SUPPORTED_EFFECTS_SCOPE_ENDGRP" +, +.br +.br +.BI " NVME_FID_SUPPORTED_EFFECTS_SCOPE_DOMAIN" +, +.br +.br +.BI " NVME_FID_SUPPORTED_EFFECTS_SCOPE_NSS" + +}; +.SH Constants +.IP "NVME_FID_SUPPORTED_EFFECTS_FSUPP" 12 +.IP "NVME_FID_SUPPORTED_EFFECTS_UDCC" 12 +.IP "NVME_FID_SUPPORTED_EFFECTS_NCC" 12 +.IP "NVME_FID_SUPPORTED_EFFECTS_NIC" 12 +.IP "NVME_FID_SUPPORTED_EFFECTS_CCC" 12 +.IP "NVME_FID_SUPPORTED_EFFECTS_UUID_SEL" 12 +.IP "NVME_FID_SUPPORTED_EFFECTS_SCOPE_SHIFT" 12 +.IP "NVME_FID_SUPPORTED_EFFECTS_SCOPE_MASK" 12 +.IP "NVME_FID_SUPPORTED_EFFECTS_SCOPE_NS" 12 +.IP "NVME_FID_SUPPORTED_EFFECTS_SCOPE_CTRL" 12 +.IP "NVME_FID_SUPPORTED_EFFECTS_SCOPE_NVM_SET" 12 +.IP "NVME_FID_SUPPORTED_EFFECTS_SCOPE_ENDGRP" 12 +.IP "NVME_FID_SUPPORTED_EFFECTS_SCOPE_DOMAIN" 12 +.IP "NVME_FID_SUPPORTED_EFFECTS_SCOPE_NSS" 12 +.SH "Description" +FID Supported and Effects Data Structure definitions diff --git a/doc/man/nvme_fid_supported_effects_log.2 b/doc/man/nvme_fid_supported_effects_log.2 new file mode 100644 index 0000000..6603c45 --- /dev/null +++ b/doc/man/nvme_fid_supported_effects_log.2 @@ -0,0 +1,17 @@ +.TH "libnvme" 9 "struct nvme_fid_supported_effects_log" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_fid_supported_effects_log \- +.SH SYNOPSIS +struct nvme_fid_supported_effects_log { +.br +.BI " __le32 fid_support[NVME_LOG_FID_SUPPORTED_EFFECTS_MAX];" +.br +.BI " +}; +.br + +.SH Members +.IP "fid_support" 12 +Feature Identifier Supported +.SH "Description" +Feature Identifiers Supported and Effects (Log Identifier 12h) diff --git a/doc/man/nvme_firmware_slot.2 b/doc/man/nvme_firmware_slot.2 new file mode 100644 index 0000000..61524c7 --- /dev/null +++ b/doc/man/nvme_firmware_slot.2 @@ -0,0 +1,27 @@ +.TH "libnvme" 9 "struct nvme_firmware_slot" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_firmware_slot \- +.SH SYNOPSIS +struct nvme_firmware_slot { +.br +.BI " __u8 afi;" +.br +.BI " __u8 rsvd1[7];" +.br +.BI " char frs[7][8];" +.br +.BI " __u8 rsvd2[448];" +.br +.BI " +}; +.br + +.SH Members +.IP "afi" 12 +Active Firmware Info +.IP "rsvd1" 12 +Reserved +.IP "frs" 12 +Firmware Revision for Slot +.IP "rsvd2" 12 +Reserved diff --git a/doc/man/nvme_first_host.2 b/doc/man/nvme_first_host.2 new file mode 100644 index 0000000..bfad78d --- /dev/null +++ b/doc/man/nvme_first_host.2 @@ -0,0 +1,11 @@ +.TH "nvme_first_host" 9 "nvme_first_host" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_first_host \- Start host iterator +.SH SYNOPSIS +.B "nvme_host_t" nvme_first_host +.BI "(nvme_root_t r " ");" +.SH ARGUMENTS +.IP "r" 12 +\fInvme_root_t\fP object +.SH "RETURN" +First \fInvme_host_t\fP object in an iterator diff --git a/doc/man/nvme_first_subsystem.2 b/doc/man/nvme_first_subsystem.2 new file mode 100644 index 0000000..c47b3d9 --- /dev/null +++ b/doc/man/nvme_first_subsystem.2 @@ -0,0 +1,11 @@ +.TH "nvme_first_subsystem" 9 "nvme_first_subsystem" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_first_subsystem \- Start subsystem iterator +.SH SYNOPSIS +.B "nvme_subsystem_t" nvme_first_subsystem +.BI "(nvme_host_t h " ");" +.SH ARGUMENTS +.IP "h" 12 +\fInvme_host_t\fP object +.SH "RETURN" +first \fInvme_subsystem_t\fP object in an iterator diff --git a/doc/man/nvme_flush.2 b/doc/man/nvme_flush.2 new file mode 100644 index 0000000..251958e --- /dev/null +++ b/doc/man/nvme_flush.2 @@ -0,0 +1,18 @@ +.TH "nvme_flush" 9 "nvme_flush" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_flush \- Send an nvme flush command +.SH SYNOPSIS +.B "int" nvme_flush +.BI "(int fd " "," +.BI "__u32 nsid " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Namespace identifier +.SH "DESCRIPTION" +The Flush command requests that the contents of volatile write cache be made +non-volatile. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_for_each_host.2 b/doc/man/nvme_for_each_host.2 new file mode 100644 index 0000000..08e4912 --- /dev/null +++ b/doc/man/nvme_for_each_host.2 @@ -0,0 +1,12 @@ +.TH "nvme_for_each_host" 9 "nvme_for_each_host" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_for_each_host \- Traverse host list +.SH SYNOPSIS +.B "nvme_for_each_host +.BI "(r " "," +.BI "h " ");" +.SH ARGUMENTS +.IP "r" 12 +\fInvme_root_t\fP object +.IP "h" 12 +\fInvme_host_t\fP object diff --git a/doc/man/nvme_for_each_host_safe.2 b/doc/man/nvme_for_each_host_safe.2 new file mode 100644 index 0000000..04f31fe --- /dev/null +++ b/doc/man/nvme_for_each_host_safe.2 @@ -0,0 +1,15 @@ +.TH "nvme_for_each_host_safe" 9 "nvme_for_each_host_safe" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_for_each_host_safe \- Traverse host list +.SH SYNOPSIS +.B "nvme_for_each_host_safe +.BI "(r " "," +.BI "h " "," +.BI "_h " ");" +.SH ARGUMENTS +.IP "r" 12 +\fInvme_root_t\fP object +.IP "h" 12 +\fInvme_host_t\fP object +.IP "_h" 12 +Temporary \fInvme_host_t\fP object diff --git a/doc/man/nvme_for_each_subsystem.2 b/doc/man/nvme_for_each_subsystem.2 new file mode 100644 index 0000000..7f50b64 --- /dev/null +++ b/doc/man/nvme_for_each_subsystem.2 @@ -0,0 +1,12 @@ +.TH "nvme_for_each_subsystem" 9 "nvme_for_each_subsystem" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_for_each_subsystem \- Traverse subsystems +.SH SYNOPSIS +.B "nvme_for_each_subsystem +.BI "(h " "," +.BI "s " ");" +.SH ARGUMENTS +.IP "h" 12 +\fInvme_host_t\fP object +.IP "s" 12 +\fInvme_subsystem_t\fP object diff --git a/doc/man/nvme_for_each_subsystem_safe.2 b/doc/man/nvme_for_each_subsystem_safe.2 new file mode 100644 index 0000000..b03d683 --- /dev/null +++ b/doc/man/nvme_for_each_subsystem_safe.2 @@ -0,0 +1,15 @@ +.TH "nvme_for_each_subsystem_safe" 9 "nvme_for_each_subsystem_safe" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_for_each_subsystem_safe \- Traverse subsystems +.SH SYNOPSIS +.B "nvme_for_each_subsystem_safe +.BI "(h " "," +.BI "s " "," +.BI "_s " ");" +.SH ARGUMENTS +.IP "h" 12 +\fInvme_host_t\fP object +.IP "s" 12 +\fInvme_subsystem_t\fP object +.IP "_s" 12 +Temporary \fInvme_subsystem_t\fP object diff --git a/doc/man/nvme_format_nvm.2 b/doc/man/nvme_format_nvm.2 new file mode 100644 index 0000000..60ffa5b --- /dev/null +++ b/doc/man/nvme_format_nvm.2 @@ -0,0 +1,17 @@ +.TH "nvme_format_nvm" 9 "nvme_format_nvm" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_format_nvm \- Format nvme namespace(s) +.SH SYNOPSIS +.B "int" nvme_format_nvm +.BI "(struct nvme_format_nvm_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_format_nvme_args\fP argument structure +.SH "DESCRIPTION" +The Format NVM command low level formats the NVM media. This command is used +by the host to change the LBA data size and/or metadata size. A low level +format may destroy all data and metadata associated with all namespaces or +only the specific namespace associated with the command +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_format_nvm_args.2 b/doc/man/nvme_format_nvm_args.2 new file mode 100644 index 0000000..53f4fcb --- /dev/null +++ b/doc/man/nvme_format_nvm_args.2 @@ -0,0 +1,52 @@ +.TH "libnvme" 9 "struct nvme_format_nvm_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_format_nvm_args \- Arguments for the Format Nvme Namespace command +.SH SYNOPSIS +struct nvme_format_nvm_args { +.br +.BI " __u32 *result;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u32 nsid;" +.br +.BI " enum nvme_cmd_format_mset mset;" +.br +.BI " enum nvme_cmd_format_pi pi;" +.br +.BI " enum nvme_cmd_format_pil pil;" +.br +.BI " enum nvme_cmd_format_ses ses;" +.br +.BI " __u8 lbaf;" +.br +.BI " +}; +.br + +.SH Members +.IP "result" 12 +The command completion result from CQE dword0 +.IP "args_size" 12 +Size of \fIstruct nvme_format_nvm_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Set to override default timeout to this value in milliseconds; +useful for long running formats. 0 will use system default. +.IP "nsid" 12 +Namespace ID to format +.IP "mset" 12 +Metadata settings (extended or separated), true if extended +.IP "pi" 12 +Protection information type +.IP "pil" 12 +Protection information location (beginning or end), true if end +.IP "ses" 12 +Secure erase settings +.IP "lbaf" 12 +Logical block address format diff --git a/doc/man/nvme_format_nvm_compln_event.2 b/doc/man/nvme_format_nvm_compln_event.2 new file mode 100644 index 0000000..d53651a --- /dev/null +++ b/doc/man/nvme_format_nvm_compln_event.2 @@ -0,0 +1,31 @@ +.TH "libnvme" 9 "struct nvme_format_nvm_compln_event" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_format_nvm_compln_event \- +.SH SYNOPSIS +struct nvme_format_nvm_compln_event { +.br +.BI " __le32 nsid;" +.br +.BI " __u8 smallest_fpi;" +.br +.BI " __u8 format_nvm_status;" +.br +.BI " __le16 compln_info;" +.br +.BI " __le32 status_field;" +.br +.BI " +}; +.br + +.SH Members +.IP "nsid" 12 +Namespace Identifier +.IP "smallest_fpi" 12 +Smallest Format Progress Indicator +.IP "format_nvm_status" 12 +Format NVM Status +.IP "compln_info" 12 +Completion Information +.IP "status_field" 12 +Status Field diff --git a/doc/man/nvme_format_nvm_start_event.2 b/doc/man/nvme_format_nvm_start_event.2 new file mode 100644 index 0000000..cff8f5f --- /dev/null +++ b/doc/man/nvme_format_nvm_start_event.2 @@ -0,0 +1,27 @@ +.TH "libnvme" 9 "struct nvme_format_nvm_start_event" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_format_nvm_start_event \- +.SH SYNOPSIS +struct nvme_format_nvm_start_event { +.br +.BI " __le32 nsid;" +.br +.BI " __u8 fna;" +.br +.BI " __u8 rsvd5[3];" +.br +.BI " __le32 format_nvm_cdw10;" +.br +.BI " +}; +.br + +.SH Members +.IP "nsid" 12 +Namespace Identifier +.IP "fna" 12 +Format NVM Attributes +.IP "rsvd5" 12 +Reserved +.IP "format_nvm_cdw10" 12 +Format NVM CDW10 diff --git a/doc/man/nvme_free_ctrl.2 b/doc/man/nvme_free_ctrl.2 new file mode 100644 index 0000000..e350001 --- /dev/null +++ b/doc/man/nvme_free_ctrl.2 @@ -0,0 +1,9 @@ +.TH "nvme_free_ctrl" 9 "nvme_free_ctrl" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_free_ctrl \- Free controller +.SH SYNOPSIS +.B "void" nvme_free_ctrl +.BI "(struct nvme_ctrl *c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance diff --git a/doc/man/nvme_free_host.2 b/doc/man/nvme_free_host.2 new file mode 100644 index 0000000..a1393ac --- /dev/null +++ b/doc/man/nvme_free_host.2 @@ -0,0 +1,9 @@ +.TH "nvme_free_host" 9 "nvme_free_host" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_free_host \- Free nvme_host_t object +.SH SYNOPSIS +.B "void" nvme_free_host +.BI "(nvme_host_t h " ");" +.SH ARGUMENTS +.IP "h" 12 +nvme_host_t object diff --git a/doc/man/nvme_free_ns.2 b/doc/man/nvme_free_ns.2 new file mode 100644 index 0000000..f8ad3e8 --- /dev/null +++ b/doc/man/nvme_free_ns.2 @@ -0,0 +1,9 @@ +.TH "nvme_free_ns" 9 "nvme_free_ns" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_free_ns \- Free a namespace object +.SH SYNOPSIS +.B "void" nvme_free_ns +.BI "(struct nvme_ns *n " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance diff --git a/doc/man/nvme_free_subsystem.2 b/doc/man/nvme_free_subsystem.2 new file mode 100644 index 0000000..121fc6c --- /dev/null +++ b/doc/man/nvme_free_subsystem.2 @@ -0,0 +1,11 @@ +.TH "nvme_free_subsystem" 9 "nvme_free_subsystem" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_free_subsystem \- Free a subsystem +.SH SYNOPSIS +.B "void" nvme_free_subsystem +.BI "(struct nvme_subsystem *s " ");" +.SH ARGUMENTS +.IP "s" 12 +subsystem +.SH "DESCRIPTION" +Frees \fIs\fP and all related objects. diff --git a/doc/man/nvme_free_tree.2 b/doc/man/nvme_free_tree.2 new file mode 100644 index 0000000..d819425 --- /dev/null +++ b/doc/man/nvme_free_tree.2 @@ -0,0 +1,11 @@ +.TH "nvme_free_tree" 9 "nvme_free_tree" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_free_tree \- Free root object +.SH SYNOPSIS +.B "void" nvme_free_tree +.BI "(nvme_root_t r " ");" +.SH ARGUMENTS +.IP "r" 12 +\fInvme_root_t\fP object +.SH "DESCRIPTION" +Free an \fInvme_root_t\fP object and all attached objects diff --git a/doc/man/nvme_fw_commit.2 b/doc/man/nvme_fw_commit.2 new file mode 100644 index 0000000..a9d1f20 --- /dev/null +++ b/doc/man/nvme_fw_commit.2 @@ -0,0 +1,16 @@ +.TH "nvme_fw_commit" 9 "nvme_fw_commit" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_fw_commit \- Commit firmware using the specified action +.SH SYNOPSIS +.B "int" nvme_fw_commit +.BI "(struct nvme_fw_commit_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_fw_commit_args\fP argument structure +.SH "DESCRIPTION" +The Firmware Commit command modifies the firmware image or Boot Partitions. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. The command +status response may specify additional reset actions required to complete +the commit process. diff --git a/doc/man/nvme_fw_commit_args.2 b/doc/man/nvme_fw_commit_args.2 new file mode 100644 index 0000000..81236ed --- /dev/null +++ b/doc/man/nvme_fw_commit_args.2 @@ -0,0 +1,39 @@ +.TH "libnvme" 9 "struct nvme_fw_commit_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_fw_commit_args \- Arguments for the NVMe Firmware Commit command +.SH SYNOPSIS +struct nvme_fw_commit_args { +.br +.BI " __u32 *result;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " enum nvme_fw_commit_ca action;" +.br +.BI " __u8 slot;" +.br +.BI " bool bpid;" +.br +.BI " +}; +.br + +.SH Members +.IP "result" 12 +The command completion result from CQE dword0 +.IP "args_size" 12 +Size of \fIstruct nvme_fw_commit_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "action" 12 +Action to use for the firmware image, see \fIenum nvme_fw_commit_ca\fP +.IP "slot" 12 +Firmware slot to commit the downloaded image +.IP "bpid" 12 +Set to true to select the boot partition id diff --git a/doc/man/nvme_fw_commit_ca.2 b/doc/man/nvme_fw_commit_ca.2 new file mode 100644 index 0000000..90194e8 --- /dev/null +++ b/doc/man/nvme_fw_commit_ca.2 @@ -0,0 +1,59 @@ +.TH "libnvme" 9 "enum nvme_fw_commit_ca" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_fw_commit_ca \- +.SH SYNOPSIS +enum nvme_fw_commit_ca { +.br +.BI " NVME_FW_COMMIT_CA_REPLACE" +, +.br +.br +.BI " NVME_FW_COMMIT_CA_REPLACE_AND_ACTIVATE" +, +.br +.br +.BI " NVME_FW_COMMIT_CA_SET_ACTIVE" +, +.br +.br +.BI " NVME_FW_COMMIT_CA_REPLACE_AND_ACTIVATE_IMMEDIATE" +, +.br +.br +.BI " NVME_FW_COMMIT_CA_REPLACE_BOOT_PARTITION" +, +.br +.br +.BI " NVME_FW_COMMIT_CA_ACTIVATE_BOOT_PARTITION" + +}; +.SH Constants +.IP "NVME_FW_COMMIT_CA_REPLACE" 12 +Downloaded image replaces the existing +image, if any, in the specified Firmware +Slot. The newly placed image is not +activated. +.IP "NVME_FW_COMMIT_CA_REPLACE_AND_ACTIVATE" 12 +Downloaded image replaces the existing +image, if any, in the specified Firmware +Slot. The newly placed image is activated +at the next Controller Level Reset. +.IP "NVME_FW_COMMIT_CA_SET_ACTIVE" 12 +The existing image in the specified +Firmware Slot is activated at the +next Controller Level Reset. +.IP "NVME_FW_COMMIT_CA_REPLACE_AND_ACTIVATE_IMMEDIATE" 12 +Downloaded image replaces the existing +image, if any, in the specified Firmware +Slot and is then activated immediately. +If there is not a newly downloaded image, +then the existing image in the specified +firmware slot is activated immediately. +.IP "NVME_FW_COMMIT_CA_REPLACE_BOOT_PARTITION" 12 +Downloaded image replaces the Boot +Partition specified by the Boot +Partition ID field. +.IP "NVME_FW_COMMIT_CA_ACTIVATE_BOOT_PARTITION" 12 +Mark the Boot Partition specified in +the BPID field as active and update +BPINFO.ABPID. diff --git a/doc/man/nvme_fw_commit_event.2 b/doc/man/nvme_fw_commit_event.2 new file mode 100644 index 0000000..30bd35f --- /dev/null +++ b/doc/man/nvme_fw_commit_event.2 @@ -0,0 +1,39 @@ +.TH "libnvme" 9 "struct nvme_fw_commit_event" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_fw_commit_event \- +.SH SYNOPSIS +struct nvme_fw_commit_event { +.br +.BI " __le64 old_fw_rev;" +.br +.BI " __le64 new_fw_rev;" +.br +.BI " __u8 fw_commit_action;" +.br +.BI " __u8 fw_slot;" +.br +.BI " __u8 sct_fw;" +.br +.BI " __u8 sc_fw;" +.br +.BI " __le16 vndr_assign_fw_commit_rc;" +.br +.BI " +}; +.br + +.SH Members +.IP "old_fw_rev" 12 +Old Firmware Revision +.IP "new_fw_rev" 12 +New Firmware Revision +.IP "fw_commit_action" 12 +Firmware Commit Action +.IP "fw_slot" 12 +Firmware Slot +.IP "sct_fw" 12 +Status Code Type for Firmware Commit Command +.IP "sc_fw" 12 +Status Returned for Firmware Commit Command +.IP "vndr_assign_fw_commit_rc" 12 +Vendor Assigned Firmware Commit Result Code diff --git a/doc/man/nvme_fw_download.2 b/doc/man/nvme_fw_download.2 new file mode 100644 index 0000000..e810902 --- /dev/null +++ b/doc/man/nvme_fw_download.2 @@ -0,0 +1,25 @@ +.TH "nvme_fw_download" 9 "nvme_fw_download" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_fw_download \- Download part or all of a firmware image to the controller +.SH SYNOPSIS +.B "int" nvme_fw_download +.BI "(struct nvme_fw_download_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_fw_download_args\fP argument structure +.SH "DESCRIPTION" +The Firmware Image Download command downloads all or a portion of an image +for a future update to the controller. The Firmware Image Download command +downloads a new image (in whole or in part) to the controller. + +The image may be constructed of multiple pieces that are individually +downloaded with separate Firmware Image Download commands. Each Firmware +Image Download command includes a Dword Offset and Number of Dwords that +specify a dword range. + +The new firmware image is not activated as part of the Firmware Image +Download command. Use the \fBnvme_fw_commit\fP to activate a newly downloaded +image. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_fw_download_args.2 b/doc/man/nvme_fw_download_args.2 new file mode 100644 index 0000000..46ba23a --- /dev/null +++ b/doc/man/nvme_fw_download_args.2 @@ -0,0 +1,39 @@ +.TH "libnvme" 9 "struct nvme_fw_download_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_fw_download_args \- Arguments for the NVMe Firmware Download command +.SH SYNOPSIS +struct nvme_fw_download_args { +.br +.BI " __u32 *result;" +.br +.BI " void *data;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u32 offset;" +.br +.BI " __u32 data_len;" +.br +.BI " +}; +.br + +.SH Members +.IP "result" 12 +The command completion result from CQE dword0 +.IP "data" 12 +Userspace address of the firmware data +.IP "args_size" 12 +Size of \fIstruct nvme_fw_download_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "offset" 12 +Offset in the firmware data +.IP "data_len" 12 +Length of data in this command in bytes diff --git a/doc/man/nvme_fw_download_seq.2 b/doc/man/nvme_fw_download_seq.2 new file mode 100644 index 0000000..9afb52c --- /dev/null +++ b/doc/man/nvme_fw_download_seq.2 @@ -0,0 +1,24 @@ +.TH "nvme_fw_download_seq" 9 "nvme_fw_download_seq" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_fw_download_seq \- Firmware download sequence +.SH SYNOPSIS +.B "int" nvme_fw_download_seq +.BI "(int fd " "," +.BI "__u32 size " "," +.BI "__u32 xfer " "," +.BI "__u32 offset " "," +.BI "void *buf " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "size" 12 +Total size of the firmware image to transfer +.IP "xfer" 12 +Maximum size to send with each partial transfer +.IP "offset" 12 +Starting offset to send with this firmware downlaod +.IP "buf" 12 +Address of buffer containing all or part of the firmware image. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_gen_dhchap_key.2 b/doc/man/nvme_gen_dhchap_key.2 new file mode 100644 index 0000000..b9a0866 --- /dev/null +++ b/doc/man/nvme_gen_dhchap_key.2 @@ -0,0 +1,24 @@ +.TH "nvme_gen_dhchap_key" 9 "nvme_gen_dhchap_key" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_gen_dhchap_key \- DH-HMAC-CHAP key generation +.SH SYNOPSIS +.B "int" nvme_gen_dhchap_key +.BI "(char *hostnqn " "," +.BI "enum nvme_hmac_alg hmac " "," +.BI "unsigned int key_len " "," +.BI "unsigned char *secret " "," +.BI "unsigned char *key " ");" +.SH ARGUMENTS +.IP "hostnqn" 12 +Host NVMe Qualified Name +.IP "hmac" 12 +HMAC algorithm +.IP "key_len" 12 +Output key length +.IP "secret" 12 +Secret to used for digest +.IP "key" 12 +Generated DH-HMAC-CHAP key +.SH "RETURN" +If key generation was successful the function returns 0 or +-1 with errno set otherwise. diff --git a/doc/man/nvme_get_ana_log_len.2 b/doc/man/nvme_get_ana_log_len.2 new file mode 100644 index 0000000..9c2efec --- /dev/null +++ b/doc/man/nvme_get_ana_log_len.2 @@ -0,0 +1,15 @@ +.TH "nvme_get_ana_log_len" 9 "nvme_get_ana_log_len" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_ana_log_len \- Retreive size of the current ANA log +.SH SYNOPSIS +.B "int" nvme_get_ana_log_len +.BI "(int fd " "," +.BI "size_t *analen " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "analen" 12 +Pointer to where the length will be set on success +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_attr.2 b/doc/man/nvme_get_attr.2 new file mode 100644 index 0000000..2c52587 --- /dev/null +++ b/doc/man/nvme_get_attr.2 @@ -0,0 +1,15 @@ +.TH "nvme_get_attr" 9 "nvme_get_attr" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_attr \- Read sysfs attribute +.SH SYNOPSIS +.B "char *" nvme_get_attr +.BI "(const char *d " "," +.BI "const char *attr " ");" +.SH ARGUMENTS +.IP "d" 12 +sysfs directory +.IP "attr" 12 +sysfs attribute name +.SH "RETURN" +String with the contents of \fIattr\fP or NULL in case of an empty value +or in case of an error (indicated by non-zero errno code). diff --git a/doc/man/nvme_get_ctrl_attr.2 b/doc/man/nvme_get_ctrl_attr.2 new file mode 100644 index 0000000..6ec20f6 --- /dev/null +++ b/doc/man/nvme_get_ctrl_attr.2 @@ -0,0 +1,15 @@ +.TH "nvme_get_ctrl_attr" 9 "nvme_get_ctrl_attr" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_ctrl_attr \- Read controller sysfs attribute +.SH SYNOPSIS +.B "char *" nvme_get_ctrl_attr +.BI "(nvme_ctrl_t c " "," +.BI "const char *attr " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.IP "attr" 12 +sysfs attribute name +.SH "RETURN" +String with the contents of \fIattr\fP or NULL in case of an empty value +or in case of an error (indicated by non-zero errno code). diff --git a/doc/man/nvme_get_ctrl_telemetry.2 b/doc/man/nvme_get_ctrl_telemetry.2 new file mode 100644 index 0000000..c77da5f --- /dev/null +++ b/doc/man/nvme_get_ctrl_telemetry.2 @@ -0,0 +1,27 @@ +.TH "nvme_get_ctrl_telemetry" 9 "nvme_get_ctrl_telemetry" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_ctrl_telemetry \- Get controller telemetry log +.SH SYNOPSIS +.B "int" nvme_get_ctrl_telemetry +.BI "(int fd " "," +.BI "bool rae " "," +.BI "struct nvme_telemetry_log **log " "," +.BI "enum nvme_telemetry_da da " "," +.BI "size_t *size " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "rae" 12 +Retain asynchronous events +.IP "log" 12 +On success, set to the value of the allocated and retrieved log. +.IP "da" 12 +Log page data area, valid values: \fIenum nvme_telemetry_da\fP +.IP "size" 12 +Ptr to the telemetry log size, so it can be returned +.SH "DESCRIPTION" +The total size allocated can be calculated as: +(nvme_telemetry_log da size + 1) * NVME_LOG_TELEM_BLOCK_SIZE. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_directive_receive_length.2 b/doc/man/nvme_get_directive_receive_length.2 new file mode 100644 index 0000000..54dd32b --- /dev/null +++ b/doc/man/nvme_get_directive_receive_length.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_directive_receive_length" 9 "nvme_get_directive_receive_length" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_directive_receive_length \- +.SH SYNOPSIS +.B "int" nvme_get_directive_receive_length +.BI "(enum nvme_directive_dtype dtype " "," +.BI "enum nvme_directive_receive_doper doper " "," +.BI "__u32 *len " ");" +.SH ARGUMENTS +.IP "dtype" 12 +Directive type, see \fIenum nvme_directive_dtype\fP +.IP "doper" 12 +Directive receive operation, see \fIenum nvme_directive_receive_doper\fP +.IP "len" 12 +On success, set to this directives payload length in bytes. +.SH "RETURN" +0 on success, -1 with errno set to EINVAL if the function did not +recognize \fIdtype\fP or \fIdoper\fP. diff --git a/doc/man/nvme_get_feature_length.2 b/doc/man/nvme_get_feature_length.2 new file mode 100644 index 0000000..c8f66a0 --- /dev/null +++ b/doc/man/nvme_get_feature_length.2 @@ -0,0 +1,19 @@ +.TH "nvme_get_feature_length" 9 "nvme_get_feature_length" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_feature_length \- Retreive the command payload length for a specific feature identifier +.SH SYNOPSIS +.B "int" nvme_get_feature_length +.BI "(int fid " "," +.BI "__u32 cdw11 " "," +.BI "__u32 *len " ");" +.SH ARGUMENTS +.IP "fid" 12 +Feature identifier, see \fIenum nvme_features_id\fP. +.IP "cdw11" 12 +The cdw11 value may affect the transfer (only known fid is +NVME_FEAT_FID_HOST_ID) +.IP "len" 12 +On success, set to this features payload length in bytes. +.SH "RETURN" +0 on success, -1 with errno set to EINVAL if the function did not +recognize \fIfid\fP. diff --git a/doc/man/nvme_get_features.2 b/doc/man/nvme_get_features.2 new file mode 100644 index 0000000..df6d662 --- /dev/null +++ b/doc/man/nvme_get_features.2 @@ -0,0 +1,12 @@ +.TH "nvme_get_features" 9 "nvme_get_features" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features \- Retrieve a feature attribute +.SH SYNOPSIS +.B "int" nvme_get_features +.BI "(struct nvme_get_features_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_get_features_args\fP argument structure +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_arbitration.2 b/doc/man/nvme_get_features_arbitration.2 new file mode 100644 index 0000000..b6a5fb5 --- /dev/null +++ b/doc/man/nvme_get_features_arbitration.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_features_arbitration" 9 "nvme_get_features_arbitration" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_arbitration \- +.SH SYNOPSIS +.B "int" nvme_get_features_arbitration +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_args.2 b/doc/man/nvme_get_features_args.2 new file mode 100644 index 0000000..ea214fa --- /dev/null +++ b/doc/man/nvme_get_features_args.2 @@ -0,0 +1,56 @@ +.TH "libnvme" 9 "struct nvme_get_features_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_get_features_args \- Arguments for the NVMe Admin Get Feature command +.SH SYNOPSIS +struct nvme_get_features_args { +.br +.BI " __u32 *result;" +.br +.BI " void *data;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u32 nsid;" +.br +.BI " enum nvme_get_features_sel sel;" +.br +.BI " __u32 cdw11;" +.br +.BI " __u32 data_len;" +.br +.BI " __u8 fid;" +.br +.BI " __u8 uuidx;" +.br +.BI " +}; +.br + +.SH Members +.IP "result" 12 +The command completion result from CQE dword0 +.IP "data" 12 +User address of feature data, if applicable +.IP "args_size" 12 +Size of \fIstruct nvme_get_features_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "nsid" 12 +Namespace ID, if applicable +.IP "sel" 12 +Select which type of attribute to return, +see \fIenum nvme_get_features_sel\fP +.IP "cdw11" 12 +Feature specific command dword11 field +.IP "data_len" 12 +Length of feature data, if applicable, in bytes +.IP "fid" 12 +Feature identifier, see \fIenum nvme_features_id\fP +.IP "uuidx" 12 +UUID Index for differentiating vendor specific encoding diff --git a/doc/man/nvme_get_features_async_event.2 b/doc/man/nvme_get_features_async_event.2 new file mode 100644 index 0000000..ffcefe9 --- /dev/null +++ b/doc/man/nvme_get_features_async_event.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_features_async_event" 9 "nvme_get_features_async_event" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_async_event \- +.SH SYNOPSIS +.B "int" nvme_get_features_async_event +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_auto_pst.2 b/doc/man/nvme_get_features_auto_pst.2 new file mode 100644 index 0000000..56824c9 --- /dev/null +++ b/doc/man/nvme_get_features_auto_pst.2 @@ -0,0 +1,20 @@ +.TH "nvme_get_features_auto_pst" 9 "nvme_get_features_auto_pst" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_auto_pst \- +.SH SYNOPSIS +.B "int" nvme_get_features_auto_pst +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "struct nvme_feat_auto_pst *apst " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "apst" 12 +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_data.2 b/doc/man/nvme_get_features_data.2 new file mode 100644 index 0000000..02b82e4 --- /dev/null +++ b/doc/man/nvme_get_features_data.2 @@ -0,0 +1,24 @@ +.TH "nvme_get_features_data" 9 "nvme_get_features_data" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_data \- Helper function for @nvme_get_features() +.SH SYNOPSIS +.B "int" nvme_get_features_data +.BI "(int fd " "," +.BI "enum nvme_features_id fid " "," +.BI "__u32 nsid " "," +.BI "__u32 data_len " "," +.BI "void *data " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "fid" 12 +Feature identifier +.IP "nsid" 12 +Namespace ID, if applicable +.IP "data_len" 12 +Length of feature data, if applicable, in bytes +.IP "data" 12 +User address of feature data, if applicable +.IP "result" 12 +The command completion result from CQE dword0 diff --git a/doc/man/nvme_get_features_endurance_event_cfg.2 b/doc/man/nvme_get_features_endurance_event_cfg.2 new file mode 100644 index 0000000..6087ec5 --- /dev/null +++ b/doc/man/nvme_get_features_endurance_event_cfg.2 @@ -0,0 +1,21 @@ +.TH "nvme_get_features_endurance_event_cfg" 9 "nvme_get_features_endurance_event_cfg" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_endurance_event_cfg \- +.SH SYNOPSIS +.B "int" nvme_get_features_endurance_event_cfg +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u16 endgid " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "endgid" 12 +Endurance Group Identifier +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_err_recovery.2 b/doc/man/nvme_get_features_err_recovery.2 new file mode 100644 index 0000000..ab1bf69 --- /dev/null +++ b/doc/man/nvme_get_features_err_recovery.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_features_err_recovery" 9 "nvme_get_features_err_recovery" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_err_recovery \- +.SH SYNOPSIS +.B "int" nvme_get_features_err_recovery +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_hctm.2 b/doc/man/nvme_get_features_hctm.2 new file mode 100644 index 0000000..d0a7d2b --- /dev/null +++ b/doc/man/nvme_get_features_hctm.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_features_hctm" 9 "nvme_get_features_hctm" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_hctm \- +.SH SYNOPSIS +.B "int" nvme_get_features_hctm +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_host_behavior.2 b/doc/man/nvme_get_features_host_behavior.2 new file mode 100644 index 0000000..720a2a6 --- /dev/null +++ b/doc/man/nvme_get_features_host_behavior.2 @@ -0,0 +1,21 @@ +.TH "nvme_get_features_host_behavior" 9 "nvme_get_features_host_behavior" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_host_behavior \- +.SH SYNOPSIS +.B "int" nvme_get_features_host_behavior +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "struct nvme_feat_host_behavior *data " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "data" 12 +Poniter to structure nvme_feat_host_behavior +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_host_id.2 b/doc/man/nvme_get_features_host_id.2 new file mode 100644 index 0000000..86e91ce --- /dev/null +++ b/doc/man/nvme_get_features_host_id.2 @@ -0,0 +1,24 @@ +.TH "nvme_get_features_host_id" 9 "nvme_get_features_host_id" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_host_id \- +.SH SYNOPSIS +.B "int" nvme_get_features_host_id +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "bool exhid " "," +.BI "__u32 len " "," +.BI "__u8 *hostid " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "exhid" 12 +Enable Extended Host Identifier +.IP "len" 12 +Length of \fIhostid\fP +.IP "hostid" 12 +Buffer for returned host ID +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_host_mem_buf.2 b/doc/man/nvme_get_features_host_mem_buf.2 new file mode 100644 index 0000000..2769024 --- /dev/null +++ b/doc/man/nvme_get_features_host_mem_buf.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_features_host_mem_buf" 9 "nvme_get_features_host_mem_buf" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_host_mem_buf \- +.SH SYNOPSIS +.B "int" nvme_get_features_host_mem_buf +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_iocs_profile.2 b/doc/man/nvme_get_features_iocs_profile.2 new file mode 100644 index 0000000..a771076 --- /dev/null +++ b/doc/man/nvme_get_features_iocs_profile.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_features_iocs_profile" 9 "nvme_get_features_iocs_profile" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_iocs_profile \- +.SH SYNOPSIS +.B "int" nvme_get_features_iocs_profile +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_irq_coalesce.2 b/doc/man/nvme_get_features_irq_coalesce.2 new file mode 100644 index 0000000..4a7974a --- /dev/null +++ b/doc/man/nvme_get_features_irq_coalesce.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_features_irq_coalesce" 9 "nvme_get_features_irq_coalesce" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_irq_coalesce \- +.SH SYNOPSIS +.B "int" nvme_get_features_irq_coalesce +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_irq_config.2 b/doc/man/nvme_get_features_irq_config.2 new file mode 100644 index 0000000..2d6a207 --- /dev/null +++ b/doc/man/nvme_get_features_irq_config.2 @@ -0,0 +1,20 @@ +.TH "nvme_get_features_irq_config" 9 "nvme_get_features_irq_config" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_irq_config \- +.SH SYNOPSIS +.B "int" nvme_get_features_irq_config +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u16 iv " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "iv" 12 +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_kato.2 b/doc/man/nvme_get_features_kato.2 new file mode 100644 index 0000000..cb9d29e --- /dev/null +++ b/doc/man/nvme_get_features_kato.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_features_kato" 9 "nvme_get_features_kato" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_kato \- +.SH SYNOPSIS +.B "int" nvme_get_features_kato +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_lba_range.2 b/doc/man/nvme_get_features_lba_range.2 new file mode 100644 index 0000000..cdb80c6 --- /dev/null +++ b/doc/man/nvme_get_features_lba_range.2 @@ -0,0 +1,21 @@ +.TH "nvme_get_features_lba_range" 9 "nvme_get_features_lba_range" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_lba_range \- +.SH SYNOPSIS +.B "int" nvme_get_features_lba_range +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "struct nvme_lba_range_type *data " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "data" 12 +User address of feature data, if applicable +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_lba_sts_interval.2 b/doc/man/nvme_get_features_lba_sts_interval.2 new file mode 100644 index 0000000..a8ba856 --- /dev/null +++ b/doc/man/nvme_get_features_lba_sts_interval.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_features_lba_sts_interval" 9 "nvme_get_features_lba_sts_interval" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_lba_sts_interval \- +.SH SYNOPSIS +.B "int" nvme_get_features_lba_sts_interval +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_nopsc.2 b/doc/man/nvme_get_features_nopsc.2 new file mode 100644 index 0000000..92b4e18 --- /dev/null +++ b/doc/man/nvme_get_features_nopsc.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_features_nopsc" 9 "nvme_get_features_nopsc" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_nopsc \- +.SH SYNOPSIS +.B "int" nvme_get_features_nopsc +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_num_queues.2 b/doc/man/nvme_get_features_num_queues.2 new file mode 100644 index 0000000..ff528b0 --- /dev/null +++ b/doc/man/nvme_get_features_num_queues.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_features_num_queues" 9 "nvme_get_features_num_queues" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_num_queues \- +.SH SYNOPSIS +.B "int" nvme_get_features_num_queues +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_plm_config.2 b/doc/man/nvme_get_features_plm_config.2 new file mode 100644 index 0000000..c9994db --- /dev/null +++ b/doc/man/nvme_get_features_plm_config.2 @@ -0,0 +1,23 @@ +.TH "nvme_get_features_plm_config" 9 "nvme_get_features_plm_config" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_plm_config \- +.SH SYNOPSIS +.B "int" nvme_get_features_plm_config +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u16 nvmsetid " "," +.BI "struct nvme_plm_config *data " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "nvmsetid" 12 +NVM set id +.IP "data" 12 +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_plm_window.2 b/doc/man/nvme_get_features_plm_window.2 new file mode 100644 index 0000000..effac98 --- /dev/null +++ b/doc/man/nvme_get_features_plm_window.2 @@ -0,0 +1,21 @@ +.TH "nvme_get_features_plm_window" 9 "nvme_get_features_plm_window" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_plm_window \- +.SH SYNOPSIS +.B "int" nvme_get_features_plm_window +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u16 nvmsetid " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "nvmsetid" 12 +NVM set id +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_power_mgmt.2 b/doc/man/nvme_get_features_power_mgmt.2 new file mode 100644 index 0000000..a8ab0f1 --- /dev/null +++ b/doc/man/nvme_get_features_power_mgmt.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_features_power_mgmt" 9 "nvme_get_features_power_mgmt" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_power_mgmt \- +.SH SYNOPSIS +.B "int" nvme_get_features_power_mgmt +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_resv_mask.2 b/doc/man/nvme_get_features_resv_mask.2 new file mode 100644 index 0000000..e197b46 --- /dev/null +++ b/doc/man/nvme_get_features_resv_mask.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_features_resv_mask" 9 "nvme_get_features_resv_mask" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_resv_mask \- +.SH SYNOPSIS +.B "int" nvme_get_features_resv_mask +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_resv_persist.2 b/doc/man/nvme_get_features_resv_persist.2 new file mode 100644 index 0000000..2146dba --- /dev/null +++ b/doc/man/nvme_get_features_resv_persist.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_features_resv_persist" 9 "nvme_get_features_resv_persist" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_resv_persist \- +.SH SYNOPSIS +.B "int" nvme_get_features_resv_persist +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_rrl.2 b/doc/man/nvme_get_features_rrl.2 new file mode 100644 index 0000000..570cbdf --- /dev/null +++ b/doc/man/nvme_get_features_rrl.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_features_rrl" 9 "nvme_get_features_rrl" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_rrl \- +.SH SYNOPSIS +.B "int" nvme_get_features_rrl +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_sanitize.2 b/doc/man/nvme_get_features_sanitize.2 new file mode 100644 index 0000000..dd81fc1 --- /dev/null +++ b/doc/man/nvme_get_features_sanitize.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_features_sanitize" 9 "nvme_get_features_sanitize" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_sanitize \- +.SH SYNOPSIS +.B "int" nvme_get_features_sanitize +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_sel.2 b/doc/man/nvme_get_features_sel.2 new file mode 100644 index 0000000..f2a9b86 --- /dev/null +++ b/doc/man/nvme_get_features_sel.2 @@ -0,0 +1,30 @@ +.TH "libnvme" 9 "enum nvme_get_features_sel" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_get_features_sel \- +.SH SYNOPSIS +enum nvme_get_features_sel { +.br +.BI " NVME_GET_FEATURES_SEL_CURRENT" +, +.br +.br +.BI " NVME_GET_FEATURES_SEL_DEFAULT" +, +.br +.br +.BI " NVME_GET_FEATURES_SEL_SAVED" +, +.br +.br +.BI " NVME_GET_FEATURES_SEL_SUPPORTED" + +}; +.SH Constants +.IP "NVME_GET_FEATURES_SEL_CURRENT" 12 +Current value +.IP "NVME_GET_FEATURES_SEL_DEFAULT" 12 +Default value +.IP "NVME_GET_FEATURES_SEL_SAVED" 12 +Saved value +.IP "NVME_GET_FEATURES_SEL_SUPPORTED" 12 +Supported capabilities diff --git a/doc/man/nvme_get_features_simple.2 b/doc/man/nvme_get_features_simple.2 new file mode 100644 index 0000000..26b4fea --- /dev/null +++ b/doc/man/nvme_get_features_simple.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_features_simple" 9 "nvme_get_features_simple" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_simple \- Helper function for @nvme_get_features() +.SH SYNOPSIS +.B "int" nvme_get_features_simple +.BI "(int fd " "," +.BI "enum nvme_features_id fid " "," +.BI "__u32 nsid " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "fid" 12 +Feature identifier +.IP "nsid" 12 +Namespace ID, if applicable +.IP "result" 12 +The command completion result from CQE dword0 diff --git a/doc/man/nvme_get_features_sw_progress.2 b/doc/man/nvme_get_features_sw_progress.2 new file mode 100644 index 0000000..602237b --- /dev/null +++ b/doc/man/nvme_get_features_sw_progress.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_features_sw_progress" 9 "nvme_get_features_sw_progress" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_sw_progress \- +.SH SYNOPSIS +.B "int" nvme_get_features_sw_progress +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_temp_thresh.2 b/doc/man/nvme_get_features_temp_thresh.2 new file mode 100644 index 0000000..7b781f2 --- /dev/null +++ b/doc/man/nvme_get_features_temp_thresh.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_features_temp_thresh" 9 "nvme_get_features_temp_thresh" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_temp_thresh \- +.SH SYNOPSIS +.B "int" nvme_get_features_temp_thresh +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_timestamp.2 b/doc/man/nvme_get_features_timestamp.2 new file mode 100644 index 0000000..4828dd1 --- /dev/null +++ b/doc/man/nvme_get_features_timestamp.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_features_timestamp" 9 "nvme_get_features_timestamp" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_timestamp \- +.SH SYNOPSIS +.B "int" nvme_get_features_timestamp +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "struct nvme_timestamp *ts " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "ts" 12 +Current timestamp +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_volatile_wc.2 b/doc/man/nvme_get_features_volatile_wc.2 new file mode 100644 index 0000000..9a3ca60 --- /dev/null +++ b/doc/man/nvme_get_features_volatile_wc.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_features_volatile_wc" 9 "nvme_get_features_volatile_wc" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_volatile_wc \- +.SH SYNOPSIS +.B "int" nvme_get_features_volatile_wc +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_write_atomic.2 b/doc/man/nvme_get_features_write_atomic.2 new file mode 100644 index 0000000..bd8cc59 --- /dev/null +++ b/doc/man/nvme_get_features_write_atomic.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_features_write_atomic" 9 "nvme_get_features_write_atomic" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_write_atomic \- +.SH SYNOPSIS +.B "int" nvme_get_features_write_atomic +.BI "(int fd " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_features_write_protect.2 b/doc/man/nvme_get_features_write_protect.2 new file mode 100644 index 0000000..5c6bee6 --- /dev/null +++ b/doc/man/nvme_get_features_write_protect.2 @@ -0,0 +1,21 @@ +.TH "nvme_get_features_write_protect" 9 "nvme_get_features_write_protect" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_features_write_protect \- +.SH SYNOPSIS +.B "int" nvme_get_features_write_protect +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "enum nvme_get_features_sel sel " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Namespace ID +.IP "sel" 12 +Select which type of attribute to return, see \fIenum nvme_get_features_sel\fP +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_host_telemetry.2 b/doc/man/nvme_get_host_telemetry.2 new file mode 100644 index 0000000..2737ee2 --- /dev/null +++ b/doc/man/nvme_get_host_telemetry.2 @@ -0,0 +1,24 @@ +.TH "nvme_get_host_telemetry" 9 "nvme_get_host_telemetry" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_host_telemetry \- Get host telemetry log +.SH SYNOPSIS +.B "int" nvme_get_host_telemetry +.BI "(int fd " "," +.BI "struct nvme_telemetry_log **log " "," +.BI "enum nvme_telemetry_da da " "," +.BI "size_t *size " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "log" 12 +On success, set to the value of the allocated and retrieved log. +.IP "da" 12 +Log page data area, valid values: \fIenum nvme_telemetry_da\fP +.IP "size" 12 +Ptr to the telemetry log size, so it can be returned +.SH "DESCRIPTION" +The total size allocated can be calculated as: +(nvme_telemetry_log da size + 1) * NVME_LOG_TELEM_BLOCK_SIZE. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_lba_status.2 b/doc/man/nvme_get_lba_status.2 new file mode 100644 index 0000000..0a0d9cd --- /dev/null +++ b/doc/man/nvme_get_lba_status.2 @@ -0,0 +1,15 @@ +.TH "nvme_get_lba_status" 9 "nvme_get_lba_status" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_lba_status \- Retrieve information on possibly unrecoverable LBAs +.SH SYNOPSIS +.B "int" nvme_get_lba_status +.BI "(struct nvme_get_lba_status_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_get_lba_status_args\fP argument structure +.SH "DESCRIPTION" +The Get LBA Status command requests information about Potentially +Unrecoverable LBAs. Refer to the specification for action type descriptions. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_lba_status_args.2 b/doc/man/nvme_get_lba_status_args.2 new file mode 100644 index 0000000..f12ab36 --- /dev/null +++ b/doc/man/nvme_get_lba_status_args.2 @@ -0,0 +1,52 @@ +.TH "libnvme" 9 "struct nvme_get_lba_status_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_get_lba_status_args \- Arguments for the NVMe Get LBA Status command +.SH SYNOPSIS +struct nvme_get_lba_status_args { +.br +.BI " __u64 slba;" +.br +.BI " __u32 *result;" +.br +.BI " struct nvme_lba_status *lbas;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u32 nsid;" +.br +.BI " __u32 mndw;" +.br +.BI " enum nvme_lba_status_atype atype;" +.br +.BI " __u16 rl;" +.br +.BI " +}; +.br + +.SH Members +.IP "slba" 12 +Starting logical block address to check statuses +.IP "result" 12 +The command completion result from CQE dword0 +.IP "lbas" 12 +Data payload to return status descriptors +.IP "args_size" 12 +Size of \fIstruct nvme_get_lba_status_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "nsid" 12 +Namespace ID to retrieve LBA status +.IP "mndw" 12 +Maximum number of dwords to return +.IP "atype" 12 +Action type mechanism to determine LBA status desctriptors to +return, see \fIenum nvme_lba_status_atype\fP +.IP "rl" 12 +Range length from slba to perform the action diff --git a/doc/man/nvme_get_lba_status_log.2 b/doc/man/nvme_get_lba_status_log.2 new file mode 100644 index 0000000..558fbaf --- /dev/null +++ b/doc/man/nvme_get_lba_status_log.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_lba_status_log" 9 "nvme_get_lba_status_log" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_lba_status_log \- Retreive the LBA Status log page +.SH SYNOPSIS +.B "int" nvme_get_lba_status_log +.BI "(int fd " "," +.BI "bool rae " "," +.BI "struct nvme_lba_status_log **log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of the nvme device +.IP "rae" 12 +Retain asynchronous events +.IP "log" 12 +On success, set to the value of the allocated and retreived log. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_log.2 b/doc/man/nvme_get_log.2 new file mode 100644 index 0000000..e0a57ea --- /dev/null +++ b/doc/man/nvme_get_log.2 @@ -0,0 +1,12 @@ +.TH "nvme_get_log" 9 "nvme_get_log" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log \- NVMe Admin Get Log command +.SH SYNOPSIS +.B "int" nvme_get_log +.BI "(struct nvme_get_log_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_get_log_args\fP argument structure +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_log_ana.2 b/doc/man/nvme_get_log_ana.2 new file mode 100644 index 0000000..24d038e --- /dev/null +++ b/doc/man/nvme_get_log_ana.2 @@ -0,0 +1,33 @@ +.TH "nvme_get_log_ana" 9 "nvme_get_log_ana" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_ana \- +.SH SYNOPSIS +.B "int" nvme_get_log_ana +.BI "(int fd " "," +.BI "enum nvme_log_ana_lsp lsp " "," +.BI "bool rae " "," +.BI "__u64 offset " "," +.BI "__u32 len " "," +.BI "void *log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "lsp" 12 +Log specific, see \fIenum nvme_get_log_ana_lsp\fP +.IP "rae" 12 +Retain asynchronous events +.IP "offset" 12 +Offset to the start of the log page +.IP "len" 12 +The allocated length of the log page +.IP "log" 12 +User address to store the ana log +.SH "DESCRIPTION" +This log consists of a header describing the log and descriptors containing +the asymmetric namespace access information for ANA Groups that contain +namespaces that are attached to the controller processing the command. + +See \fIstruct nvme_ana_rsp_hdr\fP for the defintion of the returned structure. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_log_ana_groups.2 b/doc/man/nvme_get_log_ana_groups.2 new file mode 100644 index 0000000..8e1f5c6 --- /dev/null +++ b/doc/man/nvme_get_log_ana_groups.2 @@ -0,0 +1,20 @@ +.TH "nvme_get_log_ana_groups" 9 "nvme_get_log_ana_groups" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_ana_groups \- +.SH SYNOPSIS +.B "int" nvme_get_log_ana_groups +.BI "(int fd " "," +.BI "bool rae " "," +.BI "__u32 len " "," +.BI "struct nvme_ana_group_desc *log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "rae" 12 +Retain asynchronous events +.IP "len" 12 +The allocated length of the log page +.IP "log" 12 +User address to store the ana group log +.SH "DESCRIPTION" +See \fIstruct nvme_ana_group_desc\fP for the defintion of the returned structure. diff --git a/doc/man/nvme_get_log_args.2 b/doc/man/nvme_get_log_args.2 new file mode 100644 index 0000000..60a6db6 --- /dev/null +++ b/doc/man/nvme_get_log_args.2 @@ -0,0 +1,74 @@ +.TH "libnvme" 9 "struct nvme_get_log_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_get_log_args \- Arguments for the NVMe Admin Get Log command +.SH SYNOPSIS +struct nvme_get_log_args { +.br +.BI " __u64 lpo;" +.br +.BI " __u32 *result;" +.br +.BI " void *log;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " enum nvme_cmd_get_log_lid lid;" +.br +.BI " __u32 len;" +.br +.BI " __u32 nsid;" +.br +.BI " enum nvme_csi csi;" +.br +.BI " __u16 lsi;" +.br +.BI " __u8 lsp;" +.br +.BI " __u8 uuidx;" +.br +.BI " bool rae;" +.br +.BI " bool ot;" +.br +.BI " +}; +.br + +.SH Members +.IP "lpo" 12 +Log page offset for partial log transfers +.IP "result" 12 +The command completion result from CQE dword0 +.IP "log" 12 +User space destination address to transfer the data +.IP "args_size" 12 +Length of the structure +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "lid" 12 +Log page identifier, see \fIenum nvme_cmd_get_log_lid\fP for known +values +.IP "len" 12 +Length of provided user buffer to hold the log data in bytes +.IP "nsid" 12 +Namespace identifier, if applicable +.IP "csi" 12 +Command set identifier, see \fIenum nvme_csi\fP for known values +.IP "lsi" 12 +Log Specific Identifier +.IP "lsp" 12 +Log specific field +.IP "uuidx" 12 +UUID selection, if supported +.IP "rae" 12 +Retain asynchronous events +.IP "ot" 12 +Offset Type; if set \fIlpo\fP specifies the index into the list +of data structures, otherwise \fIlpo\fP specifies the byte offset +into the log page. diff --git a/doc/man/nvme_get_log_boot_partition.2 b/doc/man/nvme_get_log_boot_partition.2 new file mode 100644 index 0000000..b6917b1 --- /dev/null +++ b/doc/man/nvme_get_log_boot_partition.2 @@ -0,0 +1,25 @@ +.TH "nvme_get_log_boot_partition" 9 "nvme_get_log_boot_partition" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_boot_partition \- +.SH SYNOPSIS +.B "int" nvme_get_log_boot_partition +.BI "(int fd " "," +.BI "bool rae " "," +.BI "__u8 lsp " "," +.BI "__u32 len " "," +.BI "struct nvme_boot_partition *part " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "rae" 12 +Retain asynchronous events +.IP "lsp" 12 +The log specified field of LID +.IP "len" 12 +The allocated size, minimum +struct nvme_boot_partition +.IP "part" 12 +User address to store the log page +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise diff --git a/doc/man/nvme_get_log_changed_ns_list.2 b/doc/man/nvme_get_log_changed_ns_list.2 new file mode 100644 index 0000000..ce4984d --- /dev/null +++ b/doc/man/nvme_get_log_changed_ns_list.2 @@ -0,0 +1,22 @@ +.TH "nvme_get_log_changed_ns_list" 9 "nvme_get_log_changed_ns_list" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_changed_ns_list \- Retrieve namespace changed list +.SH SYNOPSIS +.B "int" nvme_get_log_changed_ns_list +.BI "(int fd " "," +.BI "bool rae " "," +.BI "struct nvme_ns_list *ns_log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "rae" 12 +Retain asynchronous events +.IP "ns_log" 12 +User address to store the log page +.SH "DESCRIPTION" +This log page describes namespaces attached to this controller that have +changed since the last time the namespace was identified, been added, or +deleted. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_log_cmd_effects.2 b/doc/man/nvme_get_log_cmd_effects.2 new file mode 100644 index 0000000..b443981 --- /dev/null +++ b/doc/man/nvme_get_log_cmd_effects.2 @@ -0,0 +1,21 @@ +.TH "nvme_get_log_cmd_effects" 9 "nvme_get_log_cmd_effects" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_cmd_effects \- Retrieve nvme command effects log +.SH SYNOPSIS +.B "int" nvme_get_log_cmd_effects +.BI "(int fd " "," +.BI "enum nvme_csi csi " "," +.BI "struct nvme_cmd_effects_log *effects_log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "csi" 12 +Command Set Identifier +.IP "effects_log" 12 +User address to store the effects log +.SH "DESCRIPTION" +This log page describes the commands that the controller supports and the +effects of those commands on the state of the NVM subsystem. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_log_create_telemetry_host.2 b/doc/man/nvme_get_log_create_telemetry_host.2 new file mode 100644 index 0000000..59328c7 --- /dev/null +++ b/doc/man/nvme_get_log_create_telemetry_host.2 @@ -0,0 +1,12 @@ +.TH "nvme_get_log_create_telemetry_host" 9 "nvme_get_log_create_telemetry_host" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_create_telemetry_host \- Create host telemetry log +.SH SYNOPSIS +.B "int" nvme_get_log_create_telemetry_host +.BI "(int fd " "," +.BI "struct nvme_telemetry_log *log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "log" 12 +Userspace address of the log payload diff --git a/doc/man/nvme_get_log_device_self_test.2 b/doc/man/nvme_get_log_device_self_test.2 new file mode 100644 index 0000000..262e223 --- /dev/null +++ b/doc/man/nvme_get_log_device_self_test.2 @@ -0,0 +1,19 @@ +.TH "nvme_get_log_device_self_test" 9 "nvme_get_log_device_self_test" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_device_self_test \- Retrieve the device self test log +.SH SYNOPSIS +.B "int" nvme_get_log_device_self_test +.BI "(int fd " "," +.BI "struct nvme_self_test_log *log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "log" 12 +Userspace address of the log payload +.SH "DESCRIPTION" +The log page indicates the status of an in progress self test and the +percent complete of that operation, and the results of the previous 20 +self-test operations. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_log_discovery.2 b/doc/man/nvme_get_log_discovery.2 new file mode 100644 index 0000000..cc84ee9 --- /dev/null +++ b/doc/man/nvme_get_log_discovery.2 @@ -0,0 +1,27 @@ +.TH "nvme_get_log_discovery" 9 "nvme_get_log_discovery" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_discovery \- +.SH SYNOPSIS +.B "int" nvme_get_log_discovery +.BI "(int fd " "," +.BI "bool rae " "," +.BI "__u32 offset " "," +.BI "__u32 len " "," +.BI "void *log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "rae" 12 +Retain asynchronous events +.IP "offset" 12 +Offset of this log to retrieve +.IP "len" 12 +The allocated size for this portion of the log +.IP "log" 12 +User address to store the discovery log +.SH "DESCRIPTION" +Supported only by fabrics discovery controllers, returning discovery +records. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_log_endurance_group.2 b/doc/man/nvme_get_log_endurance_group.2 new file mode 100644 index 0000000..7a305f7 --- /dev/null +++ b/doc/man/nvme_get_log_endurance_group.2 @@ -0,0 +1,25 @@ +.TH "nvme_get_log_endurance_group" 9 "nvme_get_log_endurance_group" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_endurance_group \- +.SH SYNOPSIS +.B "int" nvme_get_log_endurance_group +.BI "(int fd " "," +.BI "__u16 endgid " "," +.BI "struct nvme_endurance_group_log *log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "endgid" 12 +Starting group identifier to return in the list +.IP "log" 12 +User address to store the endurance log +.SH "DESCRIPTION" +This log page indicates if an Endurance Group Event has occurred for a +particular Endurance Group. If an Endurance Group Event has occurred, the +details of the particular event are included in the Endurance Group +Information log page for that Endurance Group. An asynchronous event is +generated when an entry for an Endurance Group is newly added to this log +page. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_log_endurance_grp_evt.2 b/doc/man/nvme_get_log_endurance_grp_evt.2 new file mode 100644 index 0000000..81f1536 --- /dev/null +++ b/doc/man/nvme_get_log_endurance_grp_evt.2 @@ -0,0 +1,21 @@ +.TH "nvme_get_log_endurance_grp_evt" 9 "nvme_get_log_endurance_grp_evt" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_endurance_grp_evt \- +.SH SYNOPSIS +.B "int" nvme_get_log_endurance_grp_evt +.BI "(int fd " "," +.BI "bool rae " "," +.BI "__u32 offset " "," +.BI "__u32 len " "," +.BI "void *log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "rae" 12 +Retain asynchronous events +.IP "offset" 12 +Offset to the start of the log page +.IP "len" 12 +The allocated length of the log page +.IP "log" 12 +User address to store the log page diff --git a/doc/man/nvme_get_log_error.2 b/doc/man/nvme_get_log_error.2 new file mode 100644 index 0000000..2bcf0aa --- /dev/null +++ b/doc/man/nvme_get_log_error.2 @@ -0,0 +1,25 @@ +.TH "nvme_get_log_error" 9 "nvme_get_log_error" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_error \- Retrieve nvme error log +.SH SYNOPSIS +.B "int" nvme_get_log_error +.BI "(int fd " "," +.BI "unsigned nr_entries " "," +.BI "bool rae " "," +.BI "struct nvme_error_log_page *err_log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nr_entries" 12 +Number of error log entries allocated +.IP "rae" 12 +Retain asynchronous events +.IP "err_log" 12 +Array of error logs of size 'entries' +.SH "DESCRIPTION" +This log page describes extended error information for a command that +completed with error, or may report an error that is not specific to a +particular command. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_log_fid_supported_effects.2 b/doc/man/nvme_get_log_fid_supported_effects.2 new file mode 100644 index 0000000..ebe2223 --- /dev/null +++ b/doc/man/nvme_get_log_fid_supported_effects.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_log_fid_supported_effects" 9 "nvme_get_log_fid_supported_effects" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_fid_supported_effects \- +.SH SYNOPSIS +.B "int" nvme_get_log_fid_supported_effects +.BI "(int fd " "," +.BI "bool rae " "," +.BI "struct nvme_fid_supported_effects_log *log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "rae" 12 +Retain asynchronous events +.IP "log" 12 +FID Supported and Effects data structure +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise diff --git a/doc/man/nvme_get_log_fw_slot.2 b/doc/man/nvme_get_log_fw_slot.2 new file mode 100644 index 0000000..5ab7744 --- /dev/null +++ b/doc/man/nvme_get_log_fw_slot.2 @@ -0,0 +1,22 @@ +.TH "nvme_get_log_fw_slot" 9 "nvme_get_log_fw_slot" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_fw_slot \- Retrieves the controller firmware log +.SH SYNOPSIS +.B "int" nvme_get_log_fw_slot +.BI "(int fd " "," +.BI "bool rae " "," +.BI "struct nvme_firmware_slot *fw_log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "rae" 12 +Retain asynchronous events +.IP "fw_log" 12 +User address to store the log page +.SH "DESCRIPTION" +This log page describes the firmware revision stored in each firmware slot +supported. The firmware revision is indicated as an ASCII string. The log +page also indicates the active slot number. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_log_lba_status.2 b/doc/man/nvme_get_log_lba_status.2 new file mode 100644 index 0000000..f339eaa --- /dev/null +++ b/doc/man/nvme_get_log_lba_status.2 @@ -0,0 +1,21 @@ +.TH "nvme_get_log_lba_status" 9 "nvme_get_log_lba_status" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_lba_status \- +.SH SYNOPSIS +.B "int" nvme_get_log_lba_status +.BI "(int fd " "," +.BI "bool rae " "," +.BI "__u64 offset " "," +.BI "__u32 len " "," +.BI "void *log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "rae" 12 +Retain asynchronous events +.IP "offset" 12 +Offset to the start of the log page +.IP "len" 12 +The allocated length of the log page +.IP "log" 12 +User address to store the log page diff --git a/doc/man/nvme_get_log_media_unit_stat.2 b/doc/man/nvme_get_log_media_unit_stat.2 new file mode 100644 index 0000000..8c40d10 --- /dev/null +++ b/doc/man/nvme_get_log_media_unit_stat.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_log_media_unit_stat" 9 "nvme_get_log_media_unit_stat" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_media_unit_stat \- +.SH SYNOPSIS +.B "int" nvme_get_log_media_unit_stat +.BI "(int fd " "," +.BI "__u16 domid " "," +.BI "struct nvme_media_unit_stat_log *mus " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "domid" 12 +Domain Identifier selection, if supported +.IP "mus" 12 +User address to store the Media Unit statistics log +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise diff --git a/doc/man/nvme_get_log_mi_cmd_supported_effects.2 b/doc/man/nvme_get_log_mi_cmd_supported_effects.2 new file mode 100644 index 0000000..82e1aa7 --- /dev/null +++ b/doc/man/nvme_get_log_mi_cmd_supported_effects.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_log_mi_cmd_supported_effects" 9 "nvme_get_log_mi_cmd_supported_effects" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_mi_cmd_supported_effects \- displays the MI Commands Supported byt the controller +.SH SYNOPSIS +.B "int" nvme_get_log_mi_cmd_supported_effects +.BI "(int fd " "," +.BI "bool rae " "," +.BI "struct nvme_mi_cmd_supported_effects_log *log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "rae" 12 +Retain asynchronous events +.IP "log" 12 +MI Command Supported and Effects data structure +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise diff --git a/doc/man/nvme_get_log_page.2 b/doc/man/nvme_get_log_page.2 new file mode 100644 index 0000000..59edb54 --- /dev/null +++ b/doc/man/nvme_get_log_page.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_log_page" 9 "nvme_get_log_page" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_page \- Get log page data +.SH SYNOPSIS +.B "int" nvme_get_log_page +.BI "(int fd " "," +.BI "__u32 xfer_len " "," +.BI "struct nvme_get_log_args *args " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "xfer_len" 12 +Max log transfer size per request to split the total. +.IP "args" 12 +\fIstruct nvme_get_log_args\fP argument structure +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_log_persistent_event.2 b/doc/man/nvme_get_log_persistent_event.2 new file mode 100644 index 0000000..d95e984 --- /dev/null +++ b/doc/man/nvme_get_log_persistent_event.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_log_persistent_event" 9 "nvme_get_log_persistent_event" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_persistent_event \- +.SH SYNOPSIS +.B "int" nvme_get_log_persistent_event +.BI "(int fd " "," +.BI "enum nvme_pevent_log_action action " "," +.BI "__u32 size " "," +.BI "void *pevent_log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "action" 12 +Action the controller should take during processing this command +.IP "size" 12 +Size of \fIpevent_log\fP +.IP "pevent_log" 12 +User address to store the persistent event log diff --git a/doc/man/nvme_get_log_predictable_lat_event.2 b/doc/man/nvme_get_log_predictable_lat_event.2 new file mode 100644 index 0000000..a796c95 --- /dev/null +++ b/doc/man/nvme_get_log_predictable_lat_event.2 @@ -0,0 +1,21 @@ +.TH "nvme_get_log_predictable_lat_event" 9 "nvme_get_log_predictable_lat_event" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_predictable_lat_event \- +.SH SYNOPSIS +.B "int" nvme_get_log_predictable_lat_event +.BI "(int fd " "," +.BI "bool rae " "," +.BI "__u32 offset " "," +.BI "__u32 len " "," +.BI "void *log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "rae" 12 +Retain asynchronous events +.IP "offset" 12 +Offset into the predictable latency event +.IP "len" 12 +Length of provided user buffer to hold the log data in bytes +.IP "log" 12 +User address for log page data diff --git a/doc/man/nvme_get_log_predictable_lat_nvmset.2 b/doc/man/nvme_get_log_predictable_lat_nvmset.2 new file mode 100644 index 0000000..089c9d9 --- /dev/null +++ b/doc/man/nvme_get_log_predictable_lat_nvmset.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_log_predictable_lat_nvmset" 9 "nvme_get_log_predictable_lat_nvmset" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_predictable_lat_nvmset \- +.SH SYNOPSIS +.B "int" nvme_get_log_predictable_lat_nvmset +.BI "(int fd " "," +.BI "__u16 nvmsetid " "," +.BI "struct nvme_nvmset_predictable_lat_log *log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nvmsetid" 12 +NVM set id +.IP "log" 12 +User address to store the predictable latency log +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_log_reservation.2 b/doc/man/nvme_get_log_reservation.2 new file mode 100644 index 0000000..af522a2 --- /dev/null +++ b/doc/man/nvme_get_log_reservation.2 @@ -0,0 +1,15 @@ +.TH "nvme_get_log_reservation" 9 "nvme_get_log_reservation" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_reservation \- +.SH SYNOPSIS +.B "int" nvme_get_log_reservation +.BI "(int fd " "," +.BI "bool rae " "," +.BI "struct nvme_resv_notification_log *log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "rae" 12 +Retain asynchronous events +.IP "log" 12 +User address to store the reservation log diff --git a/doc/man/nvme_get_log_sanitize.2 b/doc/man/nvme_get_log_sanitize.2 new file mode 100644 index 0000000..7210a04 --- /dev/null +++ b/doc/man/nvme_get_log_sanitize.2 @@ -0,0 +1,21 @@ +.TH "nvme_get_log_sanitize" 9 "nvme_get_log_sanitize" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_sanitize \- +.SH SYNOPSIS +.B "int" nvme_get_log_sanitize +.BI "(int fd " "," +.BI "bool rae " "," +.BI "struct nvme_sanitize_log_page *log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "rae" 12 +Retain asynchronous events +.IP "log" 12 +User address to store the sanitize log +.SH "DESCRIPTION" +The Sanitize Status log page reports sanitize operation time estimates and +information about the most recent sanitize operation. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_log_smart.2 b/doc/man/nvme_get_log_smart.2 new file mode 100644 index 0000000..5e6c1e6 --- /dev/null +++ b/doc/man/nvme_get_log_smart.2 @@ -0,0 +1,28 @@ +.TH "nvme_get_log_smart" 9 "nvme_get_log_smart" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_smart \- Retrieve nvme smart log +.SH SYNOPSIS +.B "int" nvme_get_log_smart +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "bool rae " "," +.BI "struct nvme_smart_log *smart_log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Optional namespace identifier +.IP "rae" 12 +Retain asynchronous events +.IP "smart_log" 12 +User address to store the smart log +.SH "DESCRIPTION" +This log page provides SMART and general health information. The information +provided is over the life of the controller and is retained across power +cycles. To request the controller log page, the namespace identifier +specified is FFFFFFFFh. The controller may also support requesting the log +page on a per namespace basis, as indicated by bit 0 of the LPA field in the +Identify Controller data structure. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_log_support_cap_config_list.2 b/doc/man/nvme_get_log_support_cap_config_list.2 new file mode 100644 index 0000000..9eaea26 --- /dev/null +++ b/doc/man/nvme_get_log_support_cap_config_list.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_log_support_cap_config_list" 9 "nvme_get_log_support_cap_config_list" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_support_cap_config_list \- +.SH SYNOPSIS +.B "int" nvme_get_log_support_cap_config_list +.BI "(int fd " "," +.BI "__u16 domid " "," +.BI "struct nvme_supported_cap_config_list_log *cap " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "domid" 12 +Domain Identifier selection, if supported +.IP "cap" 12 +-- undescribed -- +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise diff --git a/doc/man/nvme_get_log_supported_log_pages.2 b/doc/man/nvme_get_log_supported_log_pages.2 new file mode 100644 index 0000000..6376164 --- /dev/null +++ b/doc/man/nvme_get_log_supported_log_pages.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_log_supported_log_pages" 9 "nvme_get_log_supported_log_pages" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_supported_log_pages \- Retrieve nmve supported log pages +.SH SYNOPSIS +.B "int" nvme_get_log_supported_log_pages +.BI "(int fd " "," +.BI "bool rae " "," +.BI "struct nvme_supported_log_pages *log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "rae" 12 +Retain asynchronous events +.IP "log" 12 +Array of LID supported and Effects data structures +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_log_telemetry_ctrl.2 b/doc/man/nvme_get_log_telemetry_ctrl.2 new file mode 100644 index 0000000..4d97df7 --- /dev/null +++ b/doc/man/nvme_get_log_telemetry_ctrl.2 @@ -0,0 +1,21 @@ +.TH "nvme_get_log_telemetry_ctrl" 9 "nvme_get_log_telemetry_ctrl" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_telemetry_ctrl \- +.SH SYNOPSIS +.B "int" nvme_get_log_telemetry_ctrl +.BI "(int fd " "," +.BI "bool rae " "," +.BI "__u64 offset " "," +.BI "__u32 len " "," +.BI "void *log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "rae" 12 +Retain asynchronous events +.IP "offset" 12 +Offset into the telemetry data +.IP "len" 12 +Length of provided user buffer to hold the log data in bytes +.IP "log" 12 +User address for log page data diff --git a/doc/man/nvme_get_log_telemetry_host.2 b/doc/man/nvme_get_log_telemetry_host.2 new file mode 100644 index 0000000..de8a91a --- /dev/null +++ b/doc/man/nvme_get_log_telemetry_host.2 @@ -0,0 +1,24 @@ +.TH "nvme_get_log_telemetry_host" 9 "nvme_get_log_telemetry_host" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_telemetry_host \- +.SH SYNOPSIS +.B "int" nvme_get_log_telemetry_host +.BI "(int fd " "," +.BI "__u64 offset " "," +.BI "__u32 len " "," +.BI "void *log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "offset" 12 +Offset into the telemetry data +.IP "len" 12 +Length of provided user buffer to hold the log data in bytes +.IP "log" 12 +User address for log page data +.SH "DESCRIPTION" +Retreives the Telemetry Host-Initiated log page at the requested offset +using the previously existing capture. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_log_zns_changed_zones.2 b/doc/man/nvme_get_log_zns_changed_zones.2 new file mode 100644 index 0000000..8877aaa --- /dev/null +++ b/doc/man/nvme_get_log_zns_changed_zones.2 @@ -0,0 +1,23 @@ +.TH "nvme_get_log_zns_changed_zones" 9 "nvme_get_log_zns_changed_zones" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_log_zns_changed_zones \- +.SH SYNOPSIS +.B "int" nvme_get_log_zns_changed_zones +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "bool rae " "," +.BI "struct nvme_zns_changed_zone_log *log " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Namespace ID +.IP "rae" 12 +Retain asynchronous events +.IP "log" 12 +User address to store the changed zone log +.SH "DESCRIPTION" +The list of zones that have changed state due to an exceptional event. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_logical_block_size.2 b/doc/man/nvme_get_logical_block_size.2 new file mode 100644 index 0000000..b8709eb --- /dev/null +++ b/doc/man/nvme_get_logical_block_size.2 @@ -0,0 +1,18 @@ +.TH "nvme_get_logical_block_size" 9 "nvme_get_logical_block_size" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_logical_block_size \- Retrieve block size +.SH SYNOPSIS +.B "int" nvme_get_logical_block_size +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "int *blksize " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Namespace id +.IP "blksize" 12 +Pointer to where the block size will be set on success +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_new_host_telemetry.2 b/doc/man/nvme_get_new_host_telemetry.2 new file mode 100644 index 0000000..f7bea6a --- /dev/null +++ b/doc/man/nvme_get_new_host_telemetry.2 @@ -0,0 +1,24 @@ +.TH "nvme_get_new_host_telemetry" 9 "nvme_get_new_host_telemetry" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_new_host_telemetry \- Get new host telemetry log +.SH SYNOPSIS +.B "int" nvme_get_new_host_telemetry +.BI "(int fd " "," +.BI "struct nvme_telemetry_log **log " "," +.BI "enum nvme_telemetry_da da " "," +.BI "size_t *size " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "log" 12 +On success, set to the value of the allocated and retrieved log. +.IP "da" 12 +Log page data area, valid values: \fIenum nvme_telemetry_da\fP +.IP "size" 12 +Ptr to the telemetry log size, so it can be returned +.SH "DESCRIPTION" +The total size allocated can be calculated as: +(nvme_telemetry_log da size + 1) * NVME_LOG_TELEM_BLOCK_SIZE. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_ns_attr.2 b/doc/man/nvme_get_ns_attr.2 new file mode 100644 index 0000000..9d001d9 --- /dev/null +++ b/doc/man/nvme_get_ns_attr.2 @@ -0,0 +1,15 @@ +.TH "nvme_get_ns_attr" 9 "nvme_get_ns_attr" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_ns_attr \- Read namespace sysfs attribute +.SH SYNOPSIS +.B "char *" nvme_get_ns_attr +.BI "(nvme_ns_t n " "," +.BI "const char *attr " ");" +.SH ARGUMENTS +.IP "n" 12 +nvme_ns_t object +.IP "attr" 12 +sysfs attribute name +.SH "RETURN" +String with the contents of \fIattr\fP or NULL in case of an empty value +or in case of an error (indicated by non-zero errno code). diff --git a/doc/man/nvme_get_nsid.2 b/doc/man/nvme_get_nsid.2 new file mode 100644 index 0000000..dcdfe02 --- /dev/null +++ b/doc/man/nvme_get_nsid.2 @@ -0,0 +1,19 @@ +.TH "nvme_get_nsid" 9 "nvme_get_nsid" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_nsid \- Retrieve the NSID from a namespace file descriptor +.SH SYNOPSIS +.B "int" nvme_get_nsid +.BI "(int fd " "," +.BI "__u32 *nsid " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme namespace +.IP "nsid" 12 +User pointer to namespace id +.SH "DESCRIPTION" +This should only be sent to namespace handles, not to controllers. The +kernel's interface returns the nsid as the return value. This is unfortunate +for many architectures that are incapable of allowing distinguishing a +namespace id > 0x80000000 from a negative error number. +.SH "RETURN" +0 if \fInsid\fP was set successfully or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_path_attr.2 b/doc/man/nvme_get_path_attr.2 new file mode 100644 index 0000000..ca3ed4f --- /dev/null +++ b/doc/man/nvme_get_path_attr.2 @@ -0,0 +1,15 @@ +.TH "nvme_get_path_attr" 9 "nvme_get_path_attr" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_path_attr \- Read path sysfs attribute +.SH SYNOPSIS +.B "char *" nvme_get_path_attr +.BI "(nvme_path_t p " "," +.BI "const char *attr " ");" +.SH ARGUMENTS +.IP "p" 12 +nvme_path_t object +.IP "attr" 12 +sysfs attribute name +.SH "RETURN" +String with the contents of \fIattr\fP or NULL in case of an empty value +or in case of an error (indicated by non-zero errno code). diff --git a/doc/man/nvme_get_property.2 b/doc/man/nvme_get_property.2 new file mode 100644 index 0000000..8988ae7 --- /dev/null +++ b/doc/man/nvme_get_property.2 @@ -0,0 +1,15 @@ +.TH "nvme_get_property" 9 "nvme_get_property" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_property \- Get a controller property +.SH SYNOPSIS +.B "int" nvme_get_property +.BI "(struct nvme_get_property_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_get_propert_args\fP argument structure +.SH "DESCRIPTION" +This is an NVMe-over-Fabrics specific command, not applicable to PCIe. These +properties align to the PCI MMIO controller registers. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_get_property_args.2 b/doc/man/nvme_get_property_args.2 new file mode 100644 index 0000000..f7cb1f3 --- /dev/null +++ b/doc/man/nvme_get_property_args.2 @@ -0,0 +1,31 @@ +.TH "libnvme" 9 "struct nvme_get_property_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_get_property_args \- Arguments for NVMe Get Property command +.SH SYNOPSIS +struct nvme_get_property_args { +.br +.BI " __u64 *value;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " int offset;" +.br +.BI " +}; +.br + +.SH Members +.IP "value" 12 +Where the property's value will be stored on success +.IP "args_size" 12 +Size of \fIstruct nvme_get_property_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "offset" 12 +Property offset from the base to retrieve diff --git a/doc/man/nvme_get_subsys_attr.2 b/doc/man/nvme_get_subsys_attr.2 new file mode 100644 index 0000000..6d738ef --- /dev/null +++ b/doc/man/nvme_get_subsys_attr.2 @@ -0,0 +1,15 @@ +.TH "nvme_get_subsys_attr" 9 "nvme_get_subsys_attr" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_get_subsys_attr \- Read subsystem sysfs attribute +.SH SYNOPSIS +.B "char *" nvme_get_subsys_attr +.BI "(nvme_subsystem_t s " "," +.BI "const char *attr " ");" +.SH ARGUMENTS +.IP "s" 12 +nvme_subsystem_t object +.IP "attr" 12 +sysfs attribute name +.SH "RETURN" +String with the contents of \fIattr\fP or NULL in case of an empty value +or in case of an error (indicated by non-zero errno code). diff --git a/doc/man/nvme_hmac_alg.2 b/doc/man/nvme_hmac_alg.2 new file mode 100644 index 0000000..be6a07c --- /dev/null +++ b/doc/man/nvme_hmac_alg.2 @@ -0,0 +1,30 @@ +.TH "libnvme" 9 "enum nvme_hmac_alg" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_hmac_alg \- HMAC algorithm +.SH SYNOPSIS +enum nvme_hmac_alg { +.br +.BI " NVME_HMAC_ALG_NONE" +, +.br +.br +.BI " NVME_HMAC_ALG_SHA2_256" +, +.br +.br +.BI " NVME_HMAC_ALG_SHA2_384" +, +.br +.br +.BI " NVME_HMAC_ALG_SHA2_512" + +}; +.SH Constants +.IP "NVME_HMAC_ALG_NONE" 12 +No HMAC algorithm +.IP "NVME_HMAC_ALG_SHA2_256" 12 +SHA2-256 +.IP "NVME_HMAC_ALG_SHA2_384" 12 +SHA2-384 +.IP "NVME_HMAC_ALG_SHA2_512" 12 +SHA2-512 diff --git a/doc/man/nvme_host_behavior_support.2 b/doc/man/nvme_host_behavior_support.2 new file mode 100644 index 0000000..c70a25d --- /dev/null +++ b/doc/man/nvme_host_behavior_support.2 @@ -0,0 +1,12 @@ +.TH "libnvme" 9 "enum nvme_host_behavior_support" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_host_behavior_support \- +.SH SYNOPSIS +enum nvme_host_behavior_support { +.br +.BI " NVME_ENABLE_ACRE" + +}; +.SH Constants +.IP "NVME_ENABLE_ACRE" 12 +Enable Advanced Command Retry Enable diff --git a/doc/man/nvme_host_get_dhchap_key.2 b/doc/man/nvme_host_get_dhchap_key.2 new file mode 100644 index 0000000..06505a2 --- /dev/null +++ b/doc/man/nvme_host_get_dhchap_key.2 @@ -0,0 +1,11 @@ +.TH "nvme_host_get_dhchap_key" 9 "nvme_host_get_dhchap_key" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_host_get_dhchap_key \- Return host key +.SH SYNOPSIS +.B "const char *" nvme_host_get_dhchap_key +.BI "(nvme_host_t h " ");" +.SH ARGUMENTS +.IP "h" 12 +Host for which the key should be returned +.SH "RETURN" +DH-HMAC-CHAP host key or NULL if not set diff --git a/doc/man/nvme_host_get_hostid.2 b/doc/man/nvme_host_get_hostid.2 new file mode 100644 index 0000000..6e34d5c --- /dev/null +++ b/doc/man/nvme_host_get_hostid.2 @@ -0,0 +1,11 @@ +.TH "nvme_host_get_hostid" 9 "nvme_host_get_hostid" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_host_get_hostid \- Host ID of an nvme_host_t object +.SH SYNOPSIS +.B "const char *" nvme_host_get_hostid +.BI "(nvme_host_t h " ");" +.SH ARGUMENTS +.IP "h" 12 +nvme_host_t object +.SH "RETURN" +Host ID of \fIh\fP diff --git a/doc/man/nvme_host_get_hostnqn.2 b/doc/man/nvme_host_get_hostnqn.2 new file mode 100644 index 0000000..24c44f2 --- /dev/null +++ b/doc/man/nvme_host_get_hostnqn.2 @@ -0,0 +1,11 @@ +.TH "nvme_host_get_hostnqn" 9 "nvme_host_get_hostnqn" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_host_get_hostnqn \- Host NQN of an nvme_host_t object +.SH SYNOPSIS +.B "const char *" nvme_host_get_hostnqn +.BI "(nvme_host_t h " ");" +.SH ARGUMENTS +.IP "h" 12 +nvme_host_t object +.SH "RETURN" +Host NQN of \fIh\fP diff --git a/doc/man/nvme_host_get_hostsymname.2 b/doc/man/nvme_host_get_hostsymname.2 new file mode 100644 index 0000000..9232596 --- /dev/null +++ b/doc/man/nvme_host_get_hostsymname.2 @@ -0,0 +1,12 @@ +.TH "nvme_host_get_hostsymname" 9 "nvme_host_get_hostsymname" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_host_get_hostsymname \- Get the host's symbolic name +.SH SYNOPSIS +.B "const char *" nvme_host_get_hostsymname +.BI "(nvme_host_t h " ");" +.SH ARGUMENTS +.IP "h" 12 +Host for which the symbolic name should be returned. +.SH "RETURN" +The symbolic name or NULL if a symbolic name hasn't been +configure. diff --git a/doc/man/nvme_host_get_root.2 b/doc/man/nvme_host_get_root.2 new file mode 100644 index 0000000..e2c2f92 --- /dev/null +++ b/doc/man/nvme_host_get_root.2 @@ -0,0 +1,11 @@ +.TH "nvme_host_get_root" 9 "nvme_host_get_root" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_host_get_root \- Returns nvme_root_t object +.SH SYNOPSIS +.B "nvme_root_t" nvme_host_get_root +.BI "(nvme_host_t h " ");" +.SH ARGUMENTS +.IP "h" 12 +\fInvme_host_t\fP object +.SH "RETURN" +\fInvme_root_t\fP object from \fIh\fP diff --git a/doc/man/nvme_host_mem_buf_attrs.2 b/doc/man/nvme_host_mem_buf_attrs.2 new file mode 100644 index 0000000..83bd190 --- /dev/null +++ b/doc/man/nvme_host_mem_buf_attrs.2 @@ -0,0 +1,31 @@ +.TH "libnvme" 9 "struct nvme_host_mem_buf_attrs" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_host_mem_buf_attrs \- +.SH SYNOPSIS +struct nvme_host_mem_buf_attrs { +.br +.BI " __le32 hsize;" +.br +.BI " __le32 hmdlal;" +.br +.BI " __le32 hmdlau;" +.br +.BI " __le32 hmdlec;" +.br +.BI " __u8 rsvd16[4080];" +.br +.BI " +}; +.br + +.SH Members +.IP "hsize" 12 +Host Memory Buffer Size +.IP "hmdlal" 12 +Host Memory Descriptor List Lower Address +.IP "hmdlau" 12 +Host Memory Descriptor List Upper Address +.IP "hmdlec" 12 +Host Memory Descriptor List Entry Count +.IP "rsvd16" 12 +Reserved diff --git a/doc/man/nvme_host_metadata.2 b/doc/man/nvme_host_metadata.2 new file mode 100644 index 0000000..beed508 --- /dev/null +++ b/doc/man/nvme_host_metadata.2 @@ -0,0 +1,33 @@ +.TH "libnvme" 9 "struct nvme_host_metadata" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_host_metadata \- Host Metadata Data Structure +.SH SYNOPSIS +struct nvme_host_metadata { +.br +.BI " __u8 ndesc;" +.br +.BI " __u8 rsvd1;" +.br +.BI " union {" +.br +.BI " struct nvme_metadata_element_desc descs[0];" +.br +.BI " __u8 descs_buf[4094];" +.br +.BI " };" +.br +.BI " +}; +.br + +.SH Members +.IP "ndesc" 12 +Number of metadata element descriptors +.IP "rsvd1" 12 +Reserved +.IP "{unnamed_union}" 12 +anonymous +.IP "descs" 12 +Metadata element descriptors +.IP "descs_buf" 12 +Metadata element descriptor buffer diff --git a/doc/man/nvme_host_set_dhchap_key.2 b/doc/man/nvme_host_set_dhchap_key.2 new file mode 100644 index 0000000..e7a7a1a --- /dev/null +++ b/doc/man/nvme_host_set_dhchap_key.2 @@ -0,0 +1,12 @@ +.TH "nvme_host_set_dhchap_key" 9 "nvme_host_set_dhchap_key" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_host_set_dhchap_key \- set host key +.SH SYNOPSIS +.B "void" nvme_host_set_dhchap_key +.BI "(nvme_host_t h " "," +.BI "const char *key " ");" +.SH ARGUMENTS +.IP "h" 12 +Host for which the key should be set +.IP "key" 12 +DH-HMAC-CHAP Key to set or NULL to clear existing key diff --git a/doc/man/nvme_host_set_hostsymname.2 b/doc/man/nvme_host_set_hostsymname.2 new file mode 100644 index 0000000..54c0b43 --- /dev/null +++ b/doc/man/nvme_host_set_hostsymname.2 @@ -0,0 +1,12 @@ +.TH "nvme_host_set_hostsymname" 9 "nvme_host_set_hostsymname" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_host_set_hostsymname \- Set the host's symbolic name +.SH SYNOPSIS +.B "void" nvme_host_set_hostsymname +.BI "(nvme_host_t h " "," +.BI "const char *hostsymname " ");" +.SH ARGUMENTS +.IP "h" 12 +Host for which the symbolic name should be set. +.IP "hostsymname" 12 +Symbolic name diff --git a/doc/man/nvme_id_ctrl.2 b/doc/man/nvme_id_ctrl.2 new file mode 100644 index 0000000..e42c4df --- /dev/null +++ b/doc/man/nvme_id_ctrl.2 @@ -0,0 +1,505 @@ +.TH "libnvme" 9 "struct nvme_id_ctrl" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_id_ctrl \- Identify Controller data structure +.SH SYNOPSIS +struct nvme_id_ctrl { +.br +.BI " __le16 vid;" +.br +.BI " __le16 ssvid;" +.br +.BI " char sn[20];" +.br +.BI " char mn[40];" +.br +.BI " char fr[8];" +.br +.BI " __u8 rab;" +.br +.BI " __u8 ieee[3];" +.br +.BI " __u8 cmic;" +.br +.BI " __u8 mdts;" +.br +.BI " __le16 cntlid;" +.br +.BI " __le32 ver;" +.br +.BI " __le32 rtd3r;" +.br +.BI " __le32 rtd3e;" +.br +.BI " __le32 oaes;" +.br +.BI " __le32 ctratt;" +.br +.BI " __le16 rrls;" +.br +.BI " __u8 rsvd102[9];" +.br +.BI " __u8 cntrltype;" +.br +.BI " __u8 fguid[16];" +.br +.BI " __le16 crdt1;" +.br +.BI " __le16 crdt2;" +.br +.BI " __le16 crdt3;" +.br +.BI " __u8 rsvd134[119];" +.br +.BI " __u8 nvmsr;" +.br +.BI " __u8 vwci;" +.br +.BI " __u8 mec;" +.br +.BI " __le16 oacs;" +.br +.BI " __u8 acl;" +.br +.BI " __u8 aerl;" +.br +.BI " __u8 frmw;" +.br +.BI " __u8 lpa;" +.br +.BI " __u8 elpe;" +.br +.BI " __u8 npss;" +.br +.BI " __u8 avscc;" +.br +.BI " __u8 apsta;" +.br +.BI " __le16 wctemp;" +.br +.BI " __le16 cctemp;" +.br +.BI " __le16 mtfa;" +.br +.BI " __le32 hmpre;" +.br +.BI " __le32 hmmin;" +.br +.BI " __u8 tnvmcap[16];" +.br +.BI " __u8 unvmcap[16];" +.br +.BI " __le32 rpmbs;" +.br +.BI " __le16 edstt;" +.br +.BI " __u8 dsto;" +.br +.BI " __u8 fwug;" +.br +.BI " __le16 kas;" +.br +.BI " __le16 hctma;" +.br +.BI " __le16 mntmt;" +.br +.BI " __le16 mxtmt;" +.br +.BI " __le32 sanicap;" +.br +.BI " __le32 hmminds;" +.br +.BI " __le16 hmmaxd;" +.br +.BI " __le16 nsetidmax;" +.br +.BI " __le16 endgidmax;" +.br +.BI " __u8 anatt;" +.br +.BI " __u8 anacap;" +.br +.BI " __le32 anagrpmax;" +.br +.BI " __le32 nanagrpid;" +.br +.BI " __le32 pels;" +.br +.BI " __le16 domainid;" +.br +.BI " __u8 rsvd358[10];" +.br +.BI " __u8 megcap[16];" +.br +.BI " __u8 rsvd384[128];" +.br +.BI " __u8 sqes;" +.br +.BI " __u8 cqes;" +.br +.BI " __le16 maxcmd;" +.br +.BI " __le32 nn;" +.br +.BI " __le16 oncs;" +.br +.BI " __le16 fuses;" +.br +.BI " __u8 fna;" +.br +.BI " __u8 vwc;" +.br +.BI " __le16 awun;" +.br +.BI " __le16 awupf;" +.br +.BI " __u8 icsvscc;" +.br +.BI " __u8 nwpc;" +.br +.BI " __le16 acwu;" +.br +.BI " __le16 ocfs;" +.br +.BI " __le32 sgls;" +.br +.BI " __le32 mnan;" +.br +.BI " __u8 maxdna[16];" +.br +.BI " __le32 maxcna;" +.br +.BI " __u8 rsvd564[204];" +.br +.BI " char subnqn[NVME_NQN_LENGTH];" +.br +.BI " __u8 rsvd1024[768];" +.br +.BI " __le32 ioccsz;" +.br +.BI " __le32 iorcsz;" +.br +.BI " __le16 icdoff;" +.br +.BI " __u8 fcatt;" +.br +.BI " __u8 msdbd;" +.br +.BI " __le16 ofcs;" +.br +.BI " __u8 dctype;" +.br +.BI " __u8 rsvd1807[241];" +.br +.BI " struct nvme_id_psd psd[32];" +.br +.BI " __u8 vs[1024];" +.br +.BI " +}; +.br + +.SH Members +.IP "vid" 12 +PCI Vendor ID, the company vendor identifier that is assigned by +the PCI SIG. +.IP "ssvid" 12 +PCI Subsystem Vendor ID, the company vendor identifier that is +assigned by the PCI SIG for the subsystem. +.IP "sn" 12 +Serial Number in ascii +.IP "mn" 12 +Model Number in ascii +.IP "fr" 12 +Firmware Revision in ascii, the currently active firmware +revision for the NVM subsystem +.IP "rab" 12 +Recommended Arbitration Burst, reported as a power of two +.IP "ieee" 12 +IEEE assigned Organization Unique Identifier +.IP "cmic" 12 +Controller Multipath IO and Namespace Sharing Capabilities of +the controller and NVM subsystem. See \fIenum nvme_id_ctrl_cmic\fP. +.IP "mdts" 12 +Max Data Transfer Size is the largest data transfer size. The +host should not submit a command that exceeds this maximum data +transfer size. The value is in units of the minimum memory page +size (CAP.MPSMIN) and is reported as a power of two +.IP "cntlid" 12 +Controller ID, the NVM subsystem unique controller identifier +associated with the controller. +.IP "ver" 12 +Version, this field contains the value reported in the Version +register, or property (see \fIenum nvme_registers\fP NVME_REG_VS). +.IP "rtd3r" 12 +RTD3 Resume Latency, the expected latency in microseconds to resume +from Runtime D3 +.IP "rtd3e" 12 +RTD3 Exit Latency, the typical latency in microseconds to enter +Runtime D3. +.IP "oaes" 12 +Optional Async Events Supported, see \fIenum\fP nvme_id_ctrl_oaes. +.IP "ctratt" 12 +Controller Attributes, see \fIenum\fP nvme_id_ctrl_ctratt. +.IP "rrls" 12 +Read Recovery Levels. If a bit is set, then the corresponding +Read Recovery Level is supported. If a bit is cleared, then the +corresponding Read Recovery Level is not supported. +.IP "rsvd102" 12 +Reserved +.IP "cntrltype" 12 +Controller Type, see \fIenum nvme_id_ctrl_cntrltype\fP +.IP "fguid" 12 +FRU GUID, a 128-bit value that is globally unique for a given +Field Replaceable Unit +.IP "crdt1" 12 +Controller Retry Delay time in 100 millisecod units if CQE CRD +field is 1 +.IP "crdt2" 12 +Controller Retry Delay time in 100 millisecod units if CQE CRD +field is 2 +.IP "crdt3" 12 +Controller Retry Delay time in 100 millisecod units if CQE CRD +field is 3 +.IP "rsvd134" 12 +Reserved +.IP "nvmsr" 12 +NVM Subsystem Report, see \fIenum nvme_id_ctrl_nvmsr\fP +.IP "vwci" 12 +VPD Write Cycle Information, see \fIenum nvme_id_ctrl_vwci\fP +.IP "mec" 12 +Management Endpoint Capabilities, see \fIenum nvme_id_ctrl_mec\fP +.IP "oacs" 12 +Optional Admin Command Support,the optional Admin commands and +features supported by the controller, see \fIenum nvme_id_ctrl_oacs\fP. +.IP "acl" 12 +Abort Command Limit, the maximum number of concurrently +executing Abort commands supported by the controller. This is a +0's based value. +.IP "aerl" 12 +Async Event Request Limit, the maximum number of concurrently +outstanding Asynchronous Event Request commands supported by the +controller This is a 0's based value. +.IP "frmw" 12 +Firmware Updates indicates capabilities regarding firmware +updates. See \fIenum nvme_id_ctrl_frmw\fP. +.IP "lpa" 12 +Log Page Attributes, see \fIenum nvme_id_ctrl_lpa\fP. +.IP "elpe" 12 +Error Log Page Entries, the maximum number of Error Information +log entries that are stored by the controller. This field is a +0's based value. +.IP "npss" 12 +Number of Power States Supported, the number of NVM Express +power states supported by the controller, indicating the number +of valid entries in \fIstruct nvme_id_ctrl\fP.psd. This is a 0's +based value. +.IP "avscc" 12 +Admin Vendor Specific Command Configuration, see +\fIenum nvme_id_ctrl_avscc\fP. +.IP "apsta" 12 +Autonomous Power State Transition Attributes, see +\fIenum nvme_id_ctrl_apsta\fP. +.IP "wctemp" 12 +Warning Composite Temperature Threshold indicates +the minimum Composite Temperature field value (see \fIstruct +nvme_smart_log\fP.critical_comp_time) that indicates an overheating +condition during which controller operation continues. +.IP "cctemp" 12 +Critical Composite Temperature Threshold, field indicates the +minimum Composite Temperature field value (see \fIstruct +nvme_smart_log\fP.critical_comp_time) that indicates a critical +overheating condition. +.IP "mtfa" 12 +Maximum Time for Firmware Activation indicates the maximum time +the controller temporarily stops processing commands to activate +the firmware image, specified in 100 millisecond units. This +field is always valid if the controller supports firmware +activation without a reset. +.IP "hmpre" 12 +Host Memory Buffer Preferred Size indicates the preferred size +that the host is requested to allocate for the Host Memory +Buffer feature in 4 KiB units. +.IP "hmmin" 12 +Host Memory Buffer Minimum Size indicates the minimum size that +the host is requested to allocate for the Host Memory Buffer +feature in 4 KiB units. +.IP "tnvmcap" 12 +Total NVM Capacity, the total NVM capacity in the NVM subsystem. +The value is in bytes. +.IP "unvmcap" 12 +Unallocated NVM Capacity, the unallocated NVM capacity in the +NVM subsystem. The value is in bytes. +.IP "rpmbs" 12 +Replay Protected Memory Block Support, see +\fIenum nvme_id_ctrl_rpmbs\fP. +.IP "edstt" 12 +Extended Device Self-test Time, if Device Self-test command is +supported (see \fIstruct nvme_id_ctrl\fP.oacs, NVME_CTRL_OACS_SELF_TEST), +then this field indicates the nominal amount of time in one +minute units that the controller takes to complete an extended +device self-test operation when in power state 0. +.IP "dsto" 12 +Device Self-test Options, see \fIenum nvme_id_ctrl_dsto\fP. +.IP "fwug" 12 +Firmware Update Granularity indicates the granularity and +alignment requirement of the firmware image being updated by the +Firmware Image Download command. The value is reported in 4 KiB +units. A value of 0h indicates no information on granularity is +provided. A value of FFh indicates no restriction +.IP "kas" 12 +Keep Alive Support indicates the granularity of the Keep Alive +Timer in 100 millisecond units. +.IP "hctma" 12 +Host Controlled Thermal Management Attributes, see +\fIenum nvme_id_ctrl_hctm\fP. +.IP "mntmt" 12 +Minimum Thermal Management Temperature indicates the minimum +temperature, in degrees Kelvin, that the host may request in the +Thermal Management Temperature 1 field and Thermal Management +Temperature 2 field of a Set Features command with the Feature +Identifier field set to NVME_FEAT_FID_HCTM. +.IP "mxtmt" 12 +Maximum Thermal Management Temperature indicates the maximum +temperature, in degrees Kelvin, that the host may request in the +Thermal Management Temperature 1 field and Thermal Management +Temperature 2 field of the Set Features command with the Feature +Identifier set to NVME_FEAT_FID_HCTM. +.IP "sanicap" 12 +Sanitize Capabilities, see \fIenum nvme_id_ctrl_sanicap\fP +.IP "hmminds" 12 +Host Memory Buffer Minimum Descriptor Entry Size indicates the +minimum usable size of a Host Memory Buffer Descriptor Entry in +4 KiB units. +.IP "hmmaxd" 12 +Host Memory Maximum Descriptors Entries indicates the number of +usable Host Memory Buffer Descriptor Entries. +.IP "nsetidmax" 12 +NVM Set Identifier Maximum, defines the maximum value of a valid +NVM Set Identifier for any controller in the NVM subsystem. +.IP "endgidmax" 12 +Endurance Group Identifier Maximum, defines the maximum value of +a valid Endurance Group Identifier for any controller in the NVM +subsystem. +.IP "anatt" 12 +ANA Transition Time indicates the maximum amount of time, in +seconds, for a transition between ANA states or the maximum +amount of time, in seconds, that the controller reports the ANA +change state. +.IP "anacap" 12 +Asymmetric Namespace Access Capabilities, see +\fIenum nvme_id_ctrl_anacap\fP. +.IP "anagrpmax" 12 +ANA Group Identifier Maximum indicates the maximum value of a +valid ANA Group Identifier for any controller in the NVM +subsystem. +.IP "nanagrpid" 12 +Number of ANA Group Identifiers indicates the number of ANA +groups supported by this controller. +.IP "pels" 12 +Persistent Event Log Size indicates the maximum reportable size +for the Persistent Event Log. +.IP "domainid" 12 +Domain Identifier indicates the identifier of the domain +that contains this controller. +.IP "rsvd358" 12 +Reserved +.IP "megcap" 12 +Max Endurance Group Capacity indicates the maximum capacity +of a single Endurance Group. +.IP "rsvd384" 12 +Reserved +.IP "sqes" 12 +Submission Queue Entry Size, see \fIenum nvme_id_ctrl_sqes\fP. +.IP "cqes" 12 +Completion Queue Entry Size, see \fIenum nvme_id_ctrl_cqes\fP. +.IP "maxcmd" 12 +Maximum Outstanding Commands indicates the maximum number of +commands that the controller processes at one time for a +particular queue. +.IP "nn" 12 +Number of Namespaces indicates the maximum value of a valid +nsid for the NVM subsystem. If the MNAN (\fIstruct nvme_id_ctrl\fP.mnan +field is cleared to 0h, then this field also indicates the +maximum number of namespaces supported by the NVM subsystem. +.IP "oncs" 12 +Optional NVM Command Support, see \fIenum nvme_id_ctrl_oncs\fP. +.IP "fuses" 12 +Fused Operation Support, see \fIenum nvme_id_ctrl_fuses\fP. +.IP "fna" 12 +Format NVM Attributes, see \fIenum nvme_id_ctrl_fna\fP. +.IP "vwc" 12 +Volatile Write Cache, see \fIenum nvme_id_ctrl_vwc\fP. +.IP "awun" 12 +Atomic Write Unit Normal indicates the size of the write +operation guaranteed to be written atomically to the NVM across +all namespaces with any supported namespace format during normal +operation. This field is specified in logical blocks and is a +0's based value. +.IP "awupf" 12 +Atomic Write Unit Power Fail indicates the size of the write +operation guaranteed to be written atomically to the NVM across +all namespaces with any supported namespace format during a +power fail or error condition. This field is specified in +logical blocks and is a 0’s based value. +.IP "icsvscc" 12 +NVM Vendor Specific Command Configuration, see +\fIenum nvme_id_ctrl_nvscc\fP. +.IP "nwpc" 12 +Namespace Write Protection Capabilities, see +\fIenum nvme_id_ctrl_nwpc\fP. +.IP "acwu" 12 +Atomic Compare & Write Unit indicates the size of the write +operation guaranteed to be written atomically to the NVM across +all namespaces with any supported namespace format for a Compare +and Write fused operation. This field is specified in logical +blocks and is a 0’s based value. +.IP "ocfs" 12 +Optional Copy Formats Supported, each bit n means controller +supports Copy Format n. +.IP "sgls" 12 +SGL Support, see \fIenum nvme_id_ctrl_sgls\fP +.IP "mnan" 12 +Maximum Number of Allowed Namespaces indicates the maximum +number of namespaces supported by the NVM subsystem. +.IP "maxdna" 12 +Maximum Domain Namespace Attachments indicates the maximum +of the sum of the numver of namespaces attached to each I/O +controller in the Domain. +.IP "maxcna" 12 +Maximum I/O Controller Namespace Attachments indicates the +maximum number of namespaces that are allowed to be attached to +this I/O controller. +.IP "rsvd564" 12 +Reserved +.IP "subnqn" 12 +NVM Subsystem NVMe Qualified Name, UTF-8 null terminated string +.IP "rsvd1024" 12 +Reserved +.IP "ioccsz" 12 +I/O Queue Command Capsule Supported Size, defines the maximum +I/O command capsule size in 16 byte units. +.IP "iorcsz" 12 +I/O Queue Response Capsule Supported Size, defines the maximum +I/O response capsule size in 16 byte units. +.IP "icdoff" 12 +In Capsule Data Offset, defines the offset where data starts +within a capsule. This value is applicable to I/O Queues only. +.IP "fcatt" 12 +Fabrics Controller Attributes, see \fIenum nvme_id_ctrl_fcatt\fP. +.IP "msdbd" 12 +Maximum SGL Data Block Descriptors indicates the maximum +number of SGL Data Block or Keyed SGL Data Block descriptors +that a host is allowed to place in a capsule. A value of 0h +indicates no limit. +.IP "ofcs" 12 +Optional Fabric Commands Support, see \fIenum nvme_id_ctrl_ofcs\fP. +.IP "dctype" 12 +Discovery Controller Type (DCTYPE). This field indicates what +type of Discovery controller the controller is (see enum +nvme_id_ctrl_dctype) +.IP "rsvd1807" 12 +Reserved +.IP "psd" 12 +Power State Descriptors, see \fIstruct nvme_id_psd\fP. +.IP "vs" 12 +Vendor Specific diff --git a/doc/man/nvme_id_ctrl_anacap.2 b/doc/man/nvme_id_ctrl_anacap.2 new file mode 100644 index 0000000..f5106b6 --- /dev/null +++ b/doc/man/nvme_id_ctrl_anacap.2 @@ -0,0 +1,59 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_anacap" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_anacap \- This field indicates the capabilities associated with Asymmetric Namespace Access Reporting. +.SH SYNOPSIS +enum nvme_id_ctrl_anacap { +.br +.BI " NVME_CTRL_ANACAP_OPT" +, +.br +.br +.BI " NVME_CTRL_ANACAP_NON_OPT" +, +.br +.br +.BI " NVME_CTRL_ANACAP_INACCESSIBLE" +, +.br +.br +.BI " NVME_CTRL_ANACAP_PERSISTENT_LOSS" +, +.br +.br +.BI " NVME_CTRL_ANACAP_CHANGE" +, +.br +.br +.BI " NVME_CTRL_ANACAP_GRPID_NO_CHG" +, +.br +.br +.BI " NVME_CTRL_ANACAP_GRPID_MGMT" + +}; +.SH Constants +.IP "NVME_CTRL_ANACAP_OPT" 12 +If set, then the controller is able to +report ANA Optimized state. +.IP "NVME_CTRL_ANACAP_NON_OPT" 12 +If set, then the controller is able to +report ANA Non-Optimized state. +.IP "NVME_CTRL_ANACAP_INACCESSIBLE" 12 +If set, then the controller is able to +report ANA Inaccessible state. +.IP "NVME_CTRL_ANACAP_PERSISTENT_LOSS" 12 +If set, then the controller is able to +report ANA Persistent Loss state. +.IP "NVME_CTRL_ANACAP_CHANGE" 12 +If set, then the controller is able to +report ANA Change state. +.IP "NVME_CTRL_ANACAP_GRPID_NO_CHG" 12 +If set, then the ANAGRPID field in the +Identify Namespace data structure +(\fIstruct nvme_id_ns\fP.anagrpid), does not +change while the namespace is attached to +any controller. +.IP "NVME_CTRL_ANACAP_GRPID_MGMT" 12 +If set, then the controller supports a +non-zero value in the ANAGRPID field of +the Namespace Management command. diff --git a/doc/man/nvme_id_ctrl_apsta.2 b/doc/man/nvme_id_ctrl_apsta.2 new file mode 100644 index 0000000..c0c62c2 --- /dev/null +++ b/doc/man/nvme_id_ctrl_apsta.2 @@ -0,0 +1,13 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_apsta" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_apsta \- Flags indicating the attributes of the autonomous power state transition feature. +.SH SYNOPSIS +enum nvme_id_ctrl_apsta { +.br +.BI " NVME_CTRL_APSTA_APST" + +}; +.SH Constants +.IP "NVME_CTRL_APSTA_APST" 12 +If set, then the controller supports autonomous power +state transitions. diff --git a/doc/man/nvme_id_ctrl_avscc.2 b/doc/man/nvme_id_ctrl_avscc.2 new file mode 100644 index 0000000..8864a80 --- /dev/null +++ b/doc/man/nvme_id_ctrl_avscc.2 @@ -0,0 +1,14 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_avscc" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_avscc \- Flags indicating the configuration settings for Admin Vendor Specific command handling. +.SH SYNOPSIS +enum nvme_id_ctrl_avscc { +.br +.BI " NVME_CTRL_AVSCC_AVS" + +}; +.SH Constants +.IP "NVME_CTRL_AVSCC_AVS" 12 +If set, all Admin Vendor Specific Commands use the +optional vendor specific command format with NDT and +NDM fields. diff --git a/doc/man/nvme_id_ctrl_cmic.2 b/doc/man/nvme_id_ctrl_cmic.2 new file mode 100644 index 0000000..1844dcd --- /dev/null +++ b/doc/man/nvme_id_ctrl_cmic.2 @@ -0,0 +1,43 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_cmic" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_cmic \- Controller Multipath IO and Namespace Sharing Capabilities of the controller and NVM subsystem. +.SH SYNOPSIS +enum nvme_id_ctrl_cmic { +.br +.BI " NVME_CTRL_CMIC_MULTI_PORT" +, +.br +.br +.BI " NVME_CTRL_CMIC_MULTI_CTRL" +, +.br +.br +.BI " NVME_CTRL_CMIC_MULTI_SRIOV" +, +.br +.br +.BI " NVME_CTRL_CMIC_MULTI_ANA_REPORTING" + +}; +.SH Constants +.IP "NVME_CTRL_CMIC_MULTI_PORT" 12 +If set, then the NVM subsystem may contain +more than one NVM subsystem port, otherwise +the NVM subsystem contains only a single +NVM subsystem port. +.IP "NVME_CTRL_CMIC_MULTI_CTRL" 12 +If set, then the NVM subsystem may contain +two or more controllers, otherwise the +NVM subsystem contains only a single +controller. An NVM subsystem that contains +multiple controllers may be used by +multiple hosts, or may provide multiple +paths for a single host. +.IP "NVME_CTRL_CMIC_MULTI_SRIOV" 12 +If set, then the controller is associated +with an SR-IOV Virtual Function, otherwise +it is associated with a PCI Function +or a Fabrics connection. +.IP "NVME_CTRL_CMIC_MULTI_ANA_REPORTING" 12 +If set, then the NVM subsystem supports +Asymmetric Namespace Access Reporting. diff --git a/doc/man/nvme_id_ctrl_cntrltype.2 b/doc/man/nvme_id_ctrl_cntrltype.2 new file mode 100644 index 0000000..9b3e6d8 --- /dev/null +++ b/doc/man/nvme_id_ctrl_cntrltype.2 @@ -0,0 +1,24 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_cntrltype" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_cntrltype \- Controller types +.SH SYNOPSIS +enum nvme_id_ctrl_cntrltype { +.br +.BI " NVME_CTRL_CNTRLTYPE_IO" +, +.br +.br +.BI " NVME_CTRL_CNTRLTYPE_DISCOVERY" +, +.br +.br +.BI " NVME_CTRL_CNTRLTYPE_ADMIN" + +}; +.SH Constants +.IP "NVME_CTRL_CNTRLTYPE_IO" 12 +NVM I/O controller +.IP "NVME_CTRL_CNTRLTYPE_DISCOVERY" 12 +Discovery controller +.IP "NVME_CTRL_CNTRLTYPE_ADMIN" 12 +Admin controller diff --git a/doc/man/nvme_id_ctrl_cqes.2 b/doc/man/nvme_id_ctrl_cqes.2 new file mode 100644 index 0000000..d3914f0 --- /dev/null +++ b/doc/man/nvme_id_ctrl_cqes.2 @@ -0,0 +1,20 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_cqes" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_cqes \- Defines the required and maximum Completion Queue entry size when using the NVM Command Set. +.SH SYNOPSIS +enum nvme_id_ctrl_cqes { +.br +.BI " NVME_CTRL_CQES_MIN" +, +.br +.br +.BI " NVME_CTRL_CQES_MAX" + +}; +.SH Constants +.IP "NVME_CTRL_CQES_MIN" 12 +Mask to get the value of the required Completion Queue +Entry size when using the NVM Command Set. +.IP "NVME_CTRL_CQES_MAX" 12 +Mask to get the value of the maximum Completion Queue +entry size when using the NVM Command Set. diff --git a/doc/man/nvme_id_ctrl_ctratt.2 b/doc/man/nvme_id_ctrl_ctratt.2 new file mode 100644 index 0000000..3ee3da9 --- /dev/null +++ b/doc/man/nvme_id_ctrl_ctratt.2 @@ -0,0 +1,104 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_ctratt" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_ctratt \- Controller attributes +.SH SYNOPSIS +enum nvme_id_ctrl_ctratt { +.br +.BI " NVME_CTRL_CTRATT_128_ID" +, +.br +.br +.BI " NVME_CTRL_CTRATT_NON_OP_PSP" +, +.br +.br +.BI " NVME_CTRL_CTRATT_NVM_SETS" +, +.br +.br +.BI " NVME_CTRL_CTRATT_READ_RECV_LVLS" +, +.br +.br +.BI " NVME_CTRL_CTRATT_ENDURANCE_GROUPS" +, +.br +.br +.BI " NVME_CTRL_CTRATT_PREDICTABLE_LAT" +, +.br +.br +.BI " NVME_CTRL_CTRATT_TBKAS" +, +.br +.br +.BI " NVME_CTRL_CTRATT_NAMESPACE_GRANULARITY" +, +.br +.br +.BI " NVME_CTRL_CTRATT_SQ_ASSOCIATIONS" +, +.br +.br +.BI " NVME_CTRL_CTRATT_UUID_LIST" +, +.br +.br +.BI " NVME_CTRL_CTRATT_MDS" +, +.br +.br +.BI " NVME_CTRL_CTRATT_FIXED_CAP" +, +.br +.br +.BI " NVME_CTRL_CTRATT_VARIABLE_CAP" +, +.br +.br +.BI " NVME_CTRL_CTRATT_DEL_ENDURANCE_GROUPS" +, +.br +.br +.BI " NVME_CTRL_CTRATT_DEL_NVM_SETS" +, +.br +.br +.BI " NVME_CTRL_CTRATT_ELBAS" + +}; +.SH Constants +.IP "NVME_CTRL_CTRATT_128_ID" 12 +128-bit Host Identifier supported +.IP "NVME_CTRL_CTRATT_NON_OP_PSP" 12 +Non-Operational Poser State Permissive Mode +supported +.IP "NVME_CTRL_CTRATT_NVM_SETS" 12 +NVM Sets supported +.IP "NVME_CTRL_CTRATT_READ_RECV_LVLS" 12 +Read Recovery Levels supported +.IP "NVME_CTRL_CTRATT_ENDURANCE_GROUPS" 12 +Endurance Groups supported +.IP "NVME_CTRL_CTRATT_PREDICTABLE_LAT" 12 +Predictable Latency Mode supported +.IP "NVME_CTRL_CTRATT_TBKAS" 12 +Traffic Based Keep Alive Support +.IP "NVME_CTRL_CTRATT_NAMESPACE_GRANULARITY" 12 +Namespace Granularity reporting +supported +.IP "NVME_CTRL_CTRATT_SQ_ASSOCIATIONS" 12 +SQ Associations supported +.IP "NVME_CTRL_CTRATT_UUID_LIST" 12 +UUID List reporting supported +.IP "NVME_CTRL_CTRATT_MDS" 12 +Multi-Domain Subsystem supported +.IP "NVME_CTRL_CTRATT_FIXED_CAP" 12 +Fixed Capacity Management supported +.IP "NVME_CTRL_CTRATT_VARIABLE_CAP" 12 +Variable Capacity Managment supported +.IP "NVME_CTRL_CTRATT_DEL_ENDURANCE_GROUPS" 12 +Delete Endurance Groups supported +.IP "NVME_CTRL_CTRATT_DEL_NVM_SETS" 12 +Delete NVM Sets supported +.IP "NVME_CTRL_CTRATT_ELBAS" 12 +Extended LBA Formats supported diff --git a/doc/man/nvme_id_ctrl_dctype.2 b/doc/man/nvme_id_ctrl_dctype.2 new file mode 100644 index 0000000..5548874 --- /dev/null +++ b/doc/man/nvme_id_ctrl_dctype.2 @@ -0,0 +1,24 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_dctype" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_dctype \- Discovery Controller types +.SH SYNOPSIS +enum nvme_id_ctrl_dctype { +.br +.BI " NVME_CTRL_DCTYPE_NOT_REPORTED" +, +.br +.br +.BI " NVME_CTRL_DCTYPE_DDC" +, +.br +.br +.BI " NVME_CTRL_DCTYPE_CDC" + +}; +.SH Constants +.IP "NVME_CTRL_DCTYPE_NOT_REPORTED" 12 +Not reported (I/O, Admin, and pre-TP8010) +.IP "NVME_CTRL_DCTYPE_DDC" 12 +Direct Discovery controller +.IP "NVME_CTRL_DCTYPE_CDC" 12 +Central Discovery controller diff --git a/doc/man/nvme_id_ctrl_dsto.2 b/doc/man/nvme_id_ctrl_dsto.2 new file mode 100644 index 0000000..2ede49c --- /dev/null +++ b/doc/man/nvme_id_ctrl_dsto.2 @@ -0,0 +1,13 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_dsto" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_dsto \- Flags indicating the optional Device Self-test command or operation behaviors supported by the controller or NVM subsystem. +.SH SYNOPSIS +enum nvme_id_ctrl_dsto { +.br +.BI " NVME_CTRL_DSTO_ONE_DST" + +}; +.SH Constants +.IP "NVME_CTRL_DSTO_ONE_DST" 12 +If set, then the NVM subsystem supports only one +device self-test operation in progress at a time. diff --git a/doc/man/nvme_id_ctrl_fcatt.2 b/doc/man/nvme_id_ctrl_fcatt.2 new file mode 100644 index 0000000..2f15f13 --- /dev/null +++ b/doc/man/nvme_id_ctrl_fcatt.2 @@ -0,0 +1,14 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_fcatt" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_fcatt \- This field indicates attributes of the controller that are specific to NVMe over Fabrics. +.SH SYNOPSIS +enum nvme_id_ctrl_fcatt { +.br +.BI " NVME_CTRL_FCATT_DYNAMIC" + +}; +.SH Constants +.IP "NVME_CTRL_FCATT_DYNAMIC" 12 +If cleared, then the NVM subsystem uses a dynamic +controller model. If set, then the NVM subsystem +uses a static controller model. diff --git a/doc/man/nvme_id_ctrl_fna.2 b/doc/man/nvme_id_ctrl_fna.2 new file mode 100644 index 0000000..7b68f26 --- /dev/null +++ b/doc/man/nvme_id_ctrl_fna.2 @@ -0,0 +1,39 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_fna" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_fna \- This field indicates attributes for the Format NVM command. +.SH SYNOPSIS +enum nvme_id_ctrl_fna { +.br +.BI " NVME_CTRL_FNA_FMT_ALL_NAMESPACES" +, +.br +.br +.BI " NVME_CTRL_FNA_SEC_ALL_NAMESPACES" +, +.br +.br +.BI " NVME_CTRL_FNA_CRYPTO_ERASE" + +}; +.SH Constants +.IP "NVME_CTRL_FNA_FMT_ALL_NAMESPACES" 12 +If set, then all namespaces in an NVM +subsystem shall be configured with the +same attributes and a format (excluding +secure erase) of any namespace results in +a format of all namespaces in an NVM +subsystem. If cleared, then the +controller supports format on a per +namespace basis. +.IP "NVME_CTRL_FNA_SEC_ALL_NAMESPACES" 12 +If set, then any secure erase performed +as part of a format operation results in +a secure erase of all namespaces in the +NVM subsystem. If cleared, then any +secure erase performed as part of a +format results in a secure erase of the +particular namespace specified. +.IP "NVME_CTRL_FNA_CRYPTO_ERASE" 12 +If set, then cryptographic erase is +supported. If cleared, then cryptographic +erase is not supported. diff --git a/doc/man/nvme_id_ctrl_frmw.2 b/doc/man/nvme_id_ctrl_frmw.2 new file mode 100644 index 0000000..f9e6fb0 --- /dev/null +++ b/doc/man/nvme_id_ctrl_frmw.2 @@ -0,0 +1,26 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_frmw" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_frmw \- Flags and values indicates capabilities regarding firmware updates from &struct nvme_id_ctrl.frmw. +.SH SYNOPSIS +enum nvme_id_ctrl_frmw { +.br +.BI " NVME_CTRL_FRMW_1ST_RO" +, +.br +.br +.BI " NVME_CTRL_FRMW_NR_SLOTS" +, +.br +.br +.BI " NVME_CTRL_FRMW_FW_ACT_NO_RESET" + +}; +.SH Constants +.IP "NVME_CTRL_FRMW_1ST_RO" 12 +If set, the first firmware slot is readonly +.IP "NVME_CTRL_FRMW_NR_SLOTS" 12 +Mask to get the value of the number of +firmware slots that the controller supports. +.IP "NVME_CTRL_FRMW_FW_ACT_NO_RESET" 12 +If set, the controller supports firmware +activation without a reset. diff --git a/doc/man/nvme_id_ctrl_fuses.2 b/doc/man/nvme_id_ctrl_fuses.2 new file mode 100644 index 0000000..27634d4 --- /dev/null +++ b/doc/man/nvme_id_ctrl_fuses.2 @@ -0,0 +1,13 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_fuses" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_fuses \- This field indicates the fused operations that the controller supports. +.SH SYNOPSIS +enum nvme_id_ctrl_fuses { +.br +.BI " NVME_CTRL_FUSES_COMPARE_AND_WRITE" + +}; +.SH Constants +.IP "NVME_CTRL_FUSES_COMPARE_AND_WRITE" 12 +If set, then the controller supports the +Compare and Write fused operation. diff --git a/doc/man/nvme_id_ctrl_hctm.2 b/doc/man/nvme_id_ctrl_hctm.2 new file mode 100644 index 0000000..e6d11bf --- /dev/null +++ b/doc/man/nvme_id_ctrl_hctm.2 @@ -0,0 +1,15 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_hctm" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_hctm \- Flags indicate the attributes of the host controlled thermal management feature +.SH SYNOPSIS +enum nvme_id_ctrl_hctm { +.br +.BI " NVME_CTRL_HCTMA_HCTM" + +}; +.SH Constants +.IP "NVME_CTRL_HCTMA_HCTM" 12 +then the controller supports host controlled thermal +management, and the Set Features command and Get +Features command with the Feature Identifier field +set to NVME_FEAT_FID_HCTM. diff --git a/doc/man/nvme_id_ctrl_lpa.2 b/doc/man/nvme_id_ctrl_lpa.2 new file mode 100644 index 0000000..1b88b89 --- /dev/null +++ b/doc/man/nvme_id_ctrl_lpa.2 @@ -0,0 +1,31 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_lpa" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_lpa \- Flags indicating optional attributes for log pages that are accessed via the Get Log Page command. +.SH SYNOPSIS +enum nvme_id_ctrl_lpa { +.br +.BI " NVME_CTRL_LPA_SMART_PER_NS" +, +.br +.br +.BI " NVME_CTRL_LPA_CMD_EFFECTS" +, +.br +.br +.BI " NVME_CTRL_LPA_EXTENDED" +, +.br +.br +.BI " NVME_CTRL_LPA_TELEMETRY" +, +.br +.br +.BI " NVME_CTRL_LPA_PERSETENT_EVENT" + +}; +.SH Constants +.IP "NVME_CTRL_LPA_SMART_PER_NS" 12 +.IP "NVME_CTRL_LPA_CMD_EFFECTS" 12 +.IP "NVME_CTRL_LPA_EXTENDED" 12 +.IP "NVME_CTRL_LPA_TELEMETRY" 12 +.IP "NVME_CTRL_LPA_PERSETENT_EVENT" 12 diff --git a/doc/man/nvme_id_ctrl_mec.2 b/doc/man/nvme_id_ctrl_mec.2 new file mode 100644 index 0000000..afa77b6 --- /dev/null +++ b/doc/man/nvme_id_ctrl_mec.2 @@ -0,0 +1,20 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_mec" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_mec \- Flags indicatings the capabilities of the Management Endpoint in the Controller, &struct nvme_id_ctrl.mec. +.SH SYNOPSIS +enum nvme_id_ctrl_mec { +.br +.BI " NVME_CTRL_MEC_SMBUSME" +, +.br +.br +.BI " NVME_CTRL_MEC_PCIEME" + +}; +.SH Constants +.IP "NVME_CTRL_MEC_SMBUSME" 12 +If set, then the NVM Subsystem contains a Management +Endpoint on an SMBus/I2C port. +.IP "NVME_CTRL_MEC_PCIEME" 12 +If set, then the NVM Subsystem contains a Management +Endpoint on a PCIe port. diff --git a/doc/man/nvme_id_ctrl_nvm.2 b/doc/man/nvme_id_ctrl_nvm.2 new file mode 100644 index 0000000..16554ff --- /dev/null +++ b/doc/man/nvme_id_ctrl_nvm.2 @@ -0,0 +1,39 @@ +.TH "libnvme" 9 "struct nvme_id_ctrl_nvm" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_id_ctrl_nvm \- +.SH SYNOPSIS +struct nvme_id_ctrl_nvm { +.br +.BI " __u8 vsl;" +.br +.BI " __u8 wzsl;" +.br +.BI " __u8 wusl;" +.br +.BI " __u8 dmrl;" +.br +.BI " __u32 dmrsl;" +.br +.BI " __u64 dmsl;" +.br +.BI " __u8 rsvd16[4080];" +.br +.BI " +}; +.br + +.SH Members +.IP "vsl" 12 +Verify Size Limit +.IP "wzsl" 12 +Write Zeroes Size Limit +.IP "wusl" 12 +Write Uncorrectable Size Limit +.IP "dmrl" 12 +Dataset Management Ranges Limit +.IP "dmrsl" 12 +Dataset Management Range Size Limit +.IP "dmsl" 12 +Dataset Management Size Limit +.IP "rsvd16" 12 +reserved diff --git a/doc/man/nvme_id_ctrl_nvmsr.2 b/doc/man/nvme_id_ctrl_nvmsr.2 new file mode 100644 index 0000000..e0b118f --- /dev/null +++ b/doc/man/nvme_id_ctrl_nvmsr.2 @@ -0,0 +1,22 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_nvmsr" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_nvmsr \- This field reports information associated with the NVM Subsystem, see &struct nvme_id_ctrl.nvmsr. +.SH SYNOPSIS +enum nvme_id_ctrl_nvmsr { +.br +.BI " NVME_CTRL_NVMSR_NVMESD" +, +.br +.br +.BI " NVME_CTRL_NVMSR_NVMEE" + +}; +.SH Constants +.IP "NVME_CTRL_NVMSR_NVMESD" 12 +If set, then the NVM Subsystem is part of an NVMe +Storage Device; if cleared, then the NVM Subsystem +is not part of an NVMe Storage Device. +.IP "NVME_CTRL_NVMSR_NVMEE" 12 +If set’, then the NVM Subsystem is part of an NVMe +Enclosure; if cleared, then the NVM Subsystem is +not part of an NVMe Enclosure. diff --git a/doc/man/nvme_id_ctrl_nvscc.2 b/doc/man/nvme_id_ctrl_nvscc.2 new file mode 100644 index 0000000..077c6ef --- /dev/null +++ b/doc/man/nvme_id_ctrl_nvscc.2 @@ -0,0 +1,13 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_nvscc" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_nvscc \- This field indicates the configuration settings for NVM Vendor Specific command handling. +.SH SYNOPSIS +enum nvme_id_ctrl_nvscc { +.br +.BI " NVME_CTRL_NVSCC_FMT" + +}; +.SH Constants +.IP "NVME_CTRL_NVSCC_FMT" 12 +If set, all NVM Vendor Specific Commands use the +format format with NDT and NDM fields. diff --git a/doc/man/nvme_id_ctrl_nwpc.2 b/doc/man/nvme_id_ctrl_nwpc.2 new file mode 100644 index 0000000..794afe2 --- /dev/null +++ b/doc/man/nvme_id_ctrl_nwpc.2 @@ -0,0 +1,35 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_nwpc" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_nwpc \- This field indicates the optional namespace write protection capabilities supported by the controller. +.SH SYNOPSIS +enum nvme_id_ctrl_nwpc { +.br +.BI " NVME_CTRL_NWPC_WRITE_PROTECT" +, +.br +.br +.BI " NVME_CTRL_NWPC_WRITE_PROTECT_POWER_CYCLE" +, +.br +.br +.BI " NVME_CTRL_NWPC_WRITE_PROTECT_PERMANENT" + +}; +.SH Constants +.IP "NVME_CTRL_NWPC_WRITE_PROTECT" 12 +If set, then the controller shall +support the No Write Protect and +Write Protect namespace write +protection states and may support +the Write Protect Until Power +Cycle state and Permanent Write +Protect namespace write +protection states. +.IP "NVME_CTRL_NWPC_WRITE_PROTECT_POWER_CYCLE" 12 +If set, then the controller +supports the Write Protect Until +Power Cycle state. +.IP "NVME_CTRL_NWPC_WRITE_PROTECT_PERMANENT" 12 +If set, then the controller +supports the Permanent Write +Protect state. diff --git a/doc/man/nvme_id_ctrl_oacs.2 b/doc/man/nvme_id_ctrl_oacs.2 new file mode 100644 index 0000000..d5ae344 --- /dev/null +++ b/doc/man/nvme_id_ctrl_oacs.2 @@ -0,0 +1,77 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_oacs" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_oacs \- Flags indicating the optional Admin commands and features supported by the controller, see &struct nvme_id_ctrl.oacs. +.SH SYNOPSIS +enum nvme_id_ctrl_oacs { +.br +.BI " NVME_CTRL_OACS_SECURITY" +, +.br +.br +.BI " NVME_CTRL_OACS_FORMAT" +, +.br +.br +.BI " NVME_CTRL_OACS_FW" +, +.br +.br +.BI " NVME_CTRL_OACS_NS_MGMT" +, +.br +.br +.BI " NVME_CTRL_OACS_SELF_TEST" +, +.br +.br +.BI " NVME_CTRL_OACS_DIRECTIVES" +, +.br +.br +.BI " NVME_CTRL_OACS_NVME_MI" +, +.br +.br +.BI " NVME_CTRL_OACS_VIRT_MGMT" +, +.br +.br +.BI " NVME_CTRL_OACS_DBBUF_CFG" +, +.br +.br +.BI " NVME_CTRL_OACS_LBA_STATUS" + +}; +.SH Constants +.IP "NVME_CTRL_OACS_SECURITY" 12 +If set, then the controller supports the +Security Send and Security Receive commands. +.IP "NVME_CTRL_OACS_FORMAT" 12 +If set then the controller supports the Format +NVM command. +.IP "NVME_CTRL_OACS_FW" 12 +If set, then the controller supports the +Firmware Commit and Firmware Image Download commands. +.IP "NVME_CTRL_OACS_NS_MGMT" 12 +If set, then the controller supports the +Namespace Management capability +.IP "NVME_CTRL_OACS_SELF_TEST" 12 +If set, then the controller supports the Device +Self-test command. +.IP "NVME_CTRL_OACS_DIRECTIVES" 12 +If set, then the controller supports Directives +and the Directive Send and Directive Receive +commands. +.IP "NVME_CTRL_OACS_NVME_MI" 12 +If set, then the controller supports the NVMe-MI +Send and NVMe-MI Receive commands. +.IP "NVME_CTRL_OACS_VIRT_MGMT" 12 +If set, then the controller supports the +Virtualization Management command. +.IP "NVME_CTRL_OACS_DBBUF_CFG" 12 +If set, then the controller supports the +Doorbell Buffer Config command. +.IP "NVME_CTRL_OACS_LBA_STATUS" 12 +If set, then the controller supports the Get LBA +Status capability. diff --git a/doc/man/nvme_id_ctrl_oaes.2 b/doc/man/nvme_id_ctrl_oaes.2 new file mode 100644 index 0000000..3e27733 --- /dev/null +++ b/doc/man/nvme_id_ctrl_oaes.2 @@ -0,0 +1,62 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_oaes" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_oaes \- Optional Asynchronous Events Supported +.SH SYNOPSIS +enum nvme_id_ctrl_oaes { +.br +.BI " NVME_CTRL_OAES_NA" +, +.br +.br +.BI " NVME_CTRL_OAES_FA" +, +.br +.br +.BI " NVME_CTRL_OAES_ANA" +, +.br +.br +.BI " NVME_CTRL_OAES_PLEA" +, +.br +.br +.BI " NVME_CTRL_OAES_LBAS" +, +.br +.br +.BI " NVME_CTRL_OAES_EGE" +, +.br +.br +.BI " NVME_CTRL_OAES_NS" +, +.br +.br +.BI " NVME_CTRL_OAES_ZD" +, +.br +.br +.BI " NVME_CTRL_OAES_DL" + +}; +.SH Constants +.IP "NVME_CTRL_OAES_NA" 12 +Namespace Attribute Notices event supported +.IP "NVME_CTRL_OAES_FA" 12 +Firmware Activation Notices event supported +.IP "NVME_CTRL_OAES_ANA" 12 +ANA Change Notices supported +.IP "NVME_CTRL_OAES_PLEA" 12 +Predictable Latency Event Aggregate Log +Change Notices event supported +.IP "NVME_CTRL_OAES_LBAS" 12 +LBA Status Information Notices event supported +.IP "NVME_CTRL_OAES_EGE" 12 +Endurance Group Events Aggregate Log Change +Notices event supported +.IP "NVME_CTRL_OAES_NS" 12 +Normal NVM Subsystem Shutdown event supported +.IP "NVME_CTRL_OAES_ZD" 12 +Zone Descriptor Change Notifications supported +.IP "NVME_CTRL_OAES_DL" 12 +Discover Log Page Change Notifications supported diff --git a/doc/man/nvme_id_ctrl_ofcs.2 b/doc/man/nvme_id_ctrl_ofcs.2 new file mode 100644 index 0000000..d03d025 --- /dev/null +++ b/doc/man/nvme_id_ctrl_ofcs.2 @@ -0,0 +1,14 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_ofcs" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_ofcs \- Indicate whether the controller supports optional fabric commands. +.SH SYNOPSIS +enum nvme_id_ctrl_ofcs { +.br +.BI " NVME_CTRL_OFCS_DISCONNECT" + +}; +.SH Constants +.IP "NVME_CTRL_OFCS_DISCONNECT" 12 +If set, then the controller supports the +Disconnect command and deletion of individual +I/O Queues. diff --git a/doc/man/nvme_id_ctrl_oncs.2 b/doc/man/nvme_id_ctrl_oncs.2 new file mode 100644 index 0000000..fe711b7 --- /dev/null +++ b/doc/man/nvme_id_ctrl_oncs.2 @@ -0,0 +1,65 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_oncs" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_oncs \- This field indicates the optional NVM commands and features supported by the controller. +.SH SYNOPSIS +enum nvme_id_ctrl_oncs { +.br +.BI " NVME_CTRL_ONCS_COMPARE" +, +.br +.br +.BI " NVME_CTRL_ONCS_WRITE_UNCORRECTABLE" +, +.br +.br +.BI " NVME_CTRL_ONCS_DSM" +, +.br +.br +.BI " NVME_CTRL_ONCS_WRITE_ZEROES" +, +.br +.br +.BI " NVME_CTRL_ONCS_SAVE_FEATURES" +, +.br +.br +.BI " NVME_CTRL_ONCS_RESERVATIONS" +, +.br +.br +.BI " NVME_CTRL_ONCS_TIMESTAMP" +, +.br +.br +.BI " NVME_CTRL_ONCS_VERIFY" + +}; +.SH Constants +.IP "NVME_CTRL_ONCS_COMPARE" 12 +If set, then the controller supports +the Compare command. +.IP "NVME_CTRL_ONCS_WRITE_UNCORRECTABLE" 12 +If set, then the controller supports +the Write Uncorrectable command. +.IP "NVME_CTRL_ONCS_DSM" 12 +If set, then the controller supports +the Dataset Management command. +.IP "NVME_CTRL_ONCS_WRITE_ZEROES" 12 +If set, then the controller supports +the Write Zeroes command. +.IP "NVME_CTRL_ONCS_SAVE_FEATURES" 12 +If set, then the controller supports +the Save field set to a non-zero value +in the Set Features command and the +Select field set to a non-zero value in +the Get Features command. +.IP "NVME_CTRL_ONCS_RESERVATIONS" 12 +If set, then the controller supports +reservations. +.IP "NVME_CTRL_ONCS_TIMESTAMP" 12 +If set, then the controller supports +the Timestamp feature. +.IP "NVME_CTRL_ONCS_VERIFY" 12 +If set, then the controller supports +the Verify command. diff --git a/doc/man/nvme_id_ctrl_rpmbs.2 b/doc/man/nvme_id_ctrl_rpmbs.2 new file mode 100644 index 0000000..95a861c --- /dev/null +++ b/doc/man/nvme_id_ctrl_rpmbs.2 @@ -0,0 +1,30 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_rpmbs" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_rpmbs \- This field indicates if the controller supports one or more Replay Protected Memory Blocks, from &struct nvme_id_ctrl.rpmbs. +.SH SYNOPSIS +enum nvme_id_ctrl_rpmbs { +.br +.BI " NVME_CTRL_RPMBS_NR_UNITS" +, +.br +.br +.BI " NVME_CTRL_RPMBS_AUTH_METHOD" +, +.br +.br +.BI " NVME_CTRL_RPMBS_TOTAL_SIZE" +, +.br +.br +.BI " NVME_CTRL_RPMBS_ACCESS_SIZE" + +}; +.SH Constants +.IP "NVME_CTRL_RPMBS_NR_UNITS" 12 +Mask to get the value of the Number of RPMB Units +.IP "NVME_CTRL_RPMBS_AUTH_METHOD" 12 +Mask to get the value of the Authentication Method +.IP "NVME_CTRL_RPMBS_TOTAL_SIZE" 12 +Mask to get the value of Total Size +.IP "NVME_CTRL_RPMBS_ACCESS_SIZE" 12 +Mask to get the value of Access Size diff --git a/doc/man/nvme_id_ctrl_sanicap.2 b/doc/man/nvme_id_ctrl_sanicap.2 new file mode 100644 index 0000000..1c09afc --- /dev/null +++ b/doc/man/nvme_id_ctrl_sanicap.2 @@ -0,0 +1,44 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_sanicap" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_sanicap \- Indicates attributes for sanitize operations. +.SH SYNOPSIS +enum nvme_id_ctrl_sanicap { +.br +.BI " NVME_CTRL_SANICAP_CES" +, +.br +.br +.BI " NVME_CTRL_SANICAP_BES" +, +.br +.br +.BI " NVME_CTRL_SANICAP_OWS" +, +.br +.br +.BI " NVME_CTRL_SANICAP_NDI" +, +.br +.br +.BI " NVME_CTRL_SANICAP_NODMMAS" + +}; +.SH Constants +.IP "NVME_CTRL_SANICAP_CES" 12 +Crypto Erase Support. If set, then the +controller supports the Crypto Erase sanitize operation. +.IP "NVME_CTRL_SANICAP_BES" 12 +Block Erase Support. If set, then the controller +supports the Block Erase sanitize operation. +.IP "NVME_CTRL_SANICAP_OWS" 12 +Overwrite Support. If set, then the controller +supports the Overwrite sanitize operation. +.IP "NVME_CTRL_SANICAP_NDI" 12 +No-Deallocate Inhibited. If set and the No- +Deallocate Response Mode bit is set, then the +controller deallocates after the sanitize +operation even if the No-Deallocate After +Sanitize bit is set in a Sanitize command. +.IP "NVME_CTRL_SANICAP_NODMMAS" 12 +No-Deallocate Modifies Media After Sanitize, +mask to extract value. diff --git a/doc/man/nvme_id_ctrl_sgls.2 b/doc/man/nvme_id_ctrl_sgls.2 new file mode 100644 index 0000000..efe1ddd --- /dev/null +++ b/doc/man/nvme_id_ctrl_sgls.2 @@ -0,0 +1,46 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_sgls" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_sgls \- This field indicates if SGLs are supported for the NVM Command Set and the particular SGL types supported. +.SH SYNOPSIS +enum nvme_id_ctrl_sgls { +.br +.BI " NVME_CTRL_SGLS_SUPPORTED" +, +.br +.br +.BI " NVME_CTRL_SGLS_KEYED" +, +.br +.br +.BI " NVME_CTRL_SGLS_BIT_BUCKET" +, +.br +.br +.BI " NVME_CTRL_SGLS_MPTR_BYTE_ALIGNED" +, +.br +.br +.BI " NVME_CTRL_SGLS_OVERSIZE" +, +.br +.br +.BI " NVME_CTRL_SGLS_MPTR_SGL" +, +.br +.br +.BI " NVME_CTRL_SGLS_OFFSET" +, +.br +.br +.BI " NVME_CTRL_SGLS_TPORT" + +}; +.SH Constants +.IP "NVME_CTRL_SGLS_SUPPORTED" 12 +.IP "NVME_CTRL_SGLS_KEYED" 12 +.IP "NVME_CTRL_SGLS_BIT_BUCKET" 12 +.IP "NVME_CTRL_SGLS_MPTR_BYTE_ALIGNED" 12 +.IP "NVME_CTRL_SGLS_OVERSIZE" 12 +.IP "NVME_CTRL_SGLS_MPTR_SGL" 12 +.IP "NVME_CTRL_SGLS_OFFSET" 12 +.IP "NVME_CTRL_SGLS_TPORT" 12 diff --git a/doc/man/nvme_id_ctrl_sqes.2 b/doc/man/nvme_id_ctrl_sqes.2 new file mode 100644 index 0000000..4ed6fee --- /dev/null +++ b/doc/man/nvme_id_ctrl_sqes.2 @@ -0,0 +1,20 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_sqes" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_sqes \- Defines the required and maximum Submission Queue entry size when using the NVM Command Set. +.SH SYNOPSIS +enum nvme_id_ctrl_sqes { +.br +.BI " NVME_CTRL_SQES_MIN" +, +.br +.br +.BI " NVME_CTRL_SQES_MAX" + +}; +.SH Constants +.IP "NVME_CTRL_SQES_MIN" 12 +Mask to get the value of the required Submission Queue +Entry size when using the NVM Command Set. +.IP "NVME_CTRL_SQES_MAX" 12 +Mask to get the value of the maximum Submission Queue +entry size when using the NVM Command Set. diff --git a/doc/man/nvme_id_ctrl_vwc.2 b/doc/man/nvme_id_ctrl_vwc.2 new file mode 100644 index 0000000..a020908 --- /dev/null +++ b/doc/man/nvme_id_ctrl_vwc.2 @@ -0,0 +1,22 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_vwc" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_vwc \- +.SH SYNOPSIS +enum nvme_id_ctrl_vwc { +.br +.BI " NVME_CTRL_VWC_PRESENT" +, +.br +.br +.BI " NVME_CTRL_VWC_FLUSH" + +}; +.SH Constants +.IP "NVME_CTRL_VWC_PRESENT" 12 +If set, indicates a volatile write cache is present. +If a volatile write cache is present, then the host +controls whether the volatile write cache is enabled +with a Set Features command specifying the value +NVME_FEAT_FID_VOLATILE_WC. +.IP "NVME_CTRL_VWC_FLUSH" 12 +Mask to get the value of the flush command behavior. diff --git a/doc/man/nvme_id_ctrl_vwci.2 b/doc/man/nvme_id_ctrl_vwci.2 new file mode 100644 index 0000000..4600a2c --- /dev/null +++ b/doc/man/nvme_id_ctrl_vwci.2 @@ -0,0 +1,28 @@ +.TH "libnvme" 9 "enum nvme_id_ctrl_vwci" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ctrl_vwci \- This field indicates information about remaining number of times that VPD contents are able to be updated using the VPD Write command, see &struct nvme_id_ctrl.vwci. +.SH SYNOPSIS +enum nvme_id_ctrl_vwci { +.br +.BI " NVME_CTRL_VWCI_VWCR" +, +.br +.br +.BI " NVME_CTRL_VWCI_VWCRV" + +}; +.SH Constants +.IP "NVME_CTRL_VWCI_VWCR" 12 +Mask to get value of VPD Write Cycles Remaining. If +the VPD Write Cycle Remaining Valid bit is set, then +this field contains a value indicating the remaining +number of times that VPD contents are able to be +updated using the VPD Write command. If this field is +set to 7Fh, then the remaining number of times that +VPD contents are able to be updated using the VPD +Write command is greater than or equal to 7Fh. +.IP "NVME_CTRL_VWCI_VWCRV" 12 +VPD Write Cycle Remaining Valid. If this bit is set, +then the VPD Write Cycle Remaining field is valid. If +this bit is cleared, then the VPD Write Cycles +Remaining field is invalid and cleared to 0h. diff --git a/doc/man/nvme_id_directives.2 b/doc/man/nvme_id_directives.2 new file mode 100644 index 0000000..29ef330 --- /dev/null +++ b/doc/man/nvme_id_directives.2 @@ -0,0 +1,23 @@ +.TH "libnvme" 9 "struct nvme_id_directives" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_id_directives \- +.SH SYNOPSIS +struct nvme_id_directives { +.br +.BI " __u8 supported[32];" +.br +.BI " __u8 enabled[32];" +.br +.BI " __u8 rsvd64[4032];" +.br +.BI " +}; +.br + +.SH Members +.IP "supported" 12 +Identify directive is supported +.IP "enabled" 12 +Identify directive is Enabled +.IP "rsvd64" 12 +Reserved diff --git a/doc/man/nvme_id_domain_attr.2 b/doc/man/nvme_id_domain_attr.2 new file mode 100644 index 0000000..fe69d9a --- /dev/null +++ b/doc/man/nvme_id_domain_attr.2 @@ -0,0 +1,35 @@ +.TH "libnvme" 9 "struct nvme_id_domain_attr" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_id_domain_attr \- Domain Attributes Entry +.SH SYNOPSIS +struct nvme_id_domain_attr { +.br +.BI " __le16 dom_id;" +.br +.BI " __u8 rsvd2[14];" +.br +.BI " __u8 dom_cap[16];" +.br +.BI " __u8 unalloc_dom_cap[16];" +.br +.BI " __u8 max_egrp_dom_cap[16];" +.br +.BI " __u8 rsvd64[64];" +.br +.BI " +}; +.br + +.SH Members +.IP "dom_id" 12 +Domain Identifier +.IP "rsvd2" 12 +Reserved +.IP "dom_cap" 12 +Total Domain Capacity +.IP "unalloc_dom_cap" 12 +Unallocated Domain Capacity +.IP "max_egrp_dom_cap" 12 +Max Endurance Group Domain Capacity +.IP "rsvd64" 12 +Reserved diff --git a/doc/man/nvme_id_domain_list.2 b/doc/man/nvme_id_domain_list.2 new file mode 100644 index 0000000..413aab3 --- /dev/null +++ b/doc/man/nvme_id_domain_list.2 @@ -0,0 +1,23 @@ +.TH "libnvme" 9 "struct nvme_id_domain_list" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_id_domain_list \- +.SH SYNOPSIS +struct nvme_id_domain_list { +.br +.BI " __u8 num;" +.br +.BI " __u8 rsvd[127];" +.br +.BI " struct nvme_id_domain_attr domain_attr[NVME_ID_DOMAIN_LIST_MAX];" +.br +.BI " +}; +.br + +.SH Members +.IP "num" 12 +Number of domain attributes +.IP "rsvd" 12 +Reserved +.IP "domain_attr" 12 +List of domain attributes diff --git a/doc/man/nvme_id_endurance_group_list.2 b/doc/man/nvme_id_endurance_group_list.2 new file mode 100644 index 0000000..30db7cd --- /dev/null +++ b/doc/man/nvme_id_endurance_group_list.2 @@ -0,0 +1,19 @@ +.TH "libnvme" 9 "struct nvme_id_endurance_group_list" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_id_endurance_group_list \- +.SH SYNOPSIS +struct nvme_id_endurance_group_list { +.br +.BI " __le16 num;" +.br +.BI " __le16 identifier[NVME_ID_ENDURANCE_GROUP_LIST_MAX];" +.br +.BI " +}; +.br + +.SH Members +.IP "num" 12 +Number of Identifiers +.IP "identifier" 12 +Endurance Group Identifier diff --git a/doc/man/nvme_id_independent_id_ns.2 b/doc/man/nvme_id_independent_id_ns.2 new file mode 100644 index 0000000..03281e0 --- /dev/null +++ b/doc/man/nvme_id_independent_id_ns.2 @@ -0,0 +1,56 @@ +.TH "libnvme" 9 "struct nvme_id_independent_id_ns" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_id_independent_id_ns \- +.SH SYNOPSIS +struct nvme_id_independent_id_ns { +.br +.BI " __u8 nsfeat;" +.br +.BI " __u8 nmic;" +.br +.BI " __u8 rescap;" +.br +.BI " __u8 fpi;" +.br +.BI " __le32 anagrpid;" +.br +.BI " __u8 nsattr;" +.br +.BI " __u8 rsvd9;" +.br +.BI " __le16 nvmsetid;" +.br +.BI " __le16 endgid;" +.br +.BI " __u8 nstat;" +.br +.BI " __u8 rsvd15[4081];" +.br +.BI " +}; +.br + +.SH Members +.IP "nsfeat" 12 +common namespace features +.IP "nmic" 12 +Namespace Multi-path I/O and Namespace +Sharing Capabilities +.IP "rescap" 12 +Reservation Capabilities +.IP "fpi" 12 +Format Progress Indicator +.IP "anagrpid" 12 +ANA Group Identifier +.IP "nsattr" 12 +Namespace Attributes +.IP "rsvd9" 12 +reserved +.IP "nvmsetid" 12 +NVM Set Identifier +.IP "endgid" 12 +Endurance Group Identifier +.IP "nstat" 12 +Namespace Status +.IP "rsvd15" 12 +reserved diff --git a/doc/man/nvme_id_iocs.2 b/doc/man/nvme_id_iocs.2 new file mode 100644 index 0000000..20606c9 --- /dev/null +++ b/doc/man/nvme_id_iocs.2 @@ -0,0 +1,15 @@ +.TH "libnvme" 9 "struct nvme_id_iocs" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_id_iocs \- NVMe Identify IO Command Set data structure +.SH SYNOPSIS +struct nvme_id_iocs { +.br +.BI " __u64 iocsc[512];" +.br +.BI " +}; +.br + +.SH Members +.IP "iocsc" 12 +List of supported IO Command Set Combination vectors diff --git a/doc/man/nvme_id_ns.2 b/doc/man/nvme_id_ns.2 new file mode 100644 index 0000000..9a82518 --- /dev/null +++ b/doc/man/nvme_id_ns.2 @@ -0,0 +1,237 @@ +.TH "libnvme" 9 "struct nvme_id_ns" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_id_ns \- Identify Namespace data structure +.SH SYNOPSIS +struct nvme_id_ns { +.br +.BI " __le64 nsze;" +.br +.BI " __le64 ncap;" +.br +.BI " __le64 nuse;" +.br +.BI " __u8 nsfeat;" +.br +.BI " __u8 nlbaf;" +.br +.BI " __u8 flbas;" +.br +.BI " __u8 mc;" +.br +.BI " __u8 dpc;" +.br +.BI " __u8 dps;" +.br +.BI " __u8 nmic;" +.br +.BI " __u8 rescap;" +.br +.BI " __u8 fpi;" +.br +.BI " __u8 dlfeat;" +.br +.BI " __le16 nawun;" +.br +.BI " __le16 nawupf;" +.br +.BI " __le16 nacwu;" +.br +.BI " __le16 nabsn;" +.br +.BI " __le16 nabo;" +.br +.BI " __le16 nabspf;" +.br +.BI " __le16 noiob;" +.br +.BI " __u8 nvmcap[16];" +.br +.BI " __le16 npwg;" +.br +.BI " __le16 npwa;" +.br +.BI " __le16 npdg;" +.br +.BI " __le16 npda;" +.br +.BI " __le16 nows;" +.br +.BI " __le16 mssrl;" +.br +.BI " __le32 mcl;" +.br +.BI " __u8 msrc;" +.br +.BI " __u8 rsvd81;" +.br +.BI " __u8 nulbaf;" +.br +.BI " __u8 rsvd83[9];" +.br +.BI " __le32 anagrpid;" +.br +.BI " __u8 rsvd96[3];" +.br +.BI " __u8 nsattr;" +.br +.BI " __le16 nvmsetid;" +.br +.BI " __le16 endgid;" +.br +.BI " __u8 nguid[16];" +.br +.BI " __u8 eui64[8];" +.br +.BI " struct nvme_lbaf lbaf[64];" +.br +.BI " __le64 lbstm;" +.br +.BI " __u8 vs[3704];" +.br +.BI " +}; +.br + +.SH Members +.IP "nsze" 12 +Namespace Size indicates the total size of the namespace in +logical blocks. The number of logical blocks is based on the +formatted LBA size. +.IP "ncap" 12 +Namespace Capacity indicates the maximum number of logical blocks +that may be allocated in the namespace at any point in time. The +number of logical blocks is based on the formatted LBA size. +.IP "nuse" 12 +Namespace Utilization indicates the current number of logical +blocks allocated in the namespace. This field is smaller than or +equal to the Namespace Capacity. The number of logical blocks is +based on the formatted LBA size. +.IP "nsfeat" 12 +Namespace Features, see \fIenum nvme_id_nsfeat\fP. +.IP "nlbaf" 12 +Number of LBA Formats defines the number of supported LBA data +size and metadata size combinations supported by the namespace +and the highest possible index to \fIstruct nvme_id_ns\fP.lbaf. +.IP "flbas" 12 +Formatted LBA Size, see \fIenum nvme_id_ns_flbas\fP. +.IP "mc" 12 +Metadata Capabilities, see \fIenum nvme_id_ns_mc\fP. +.IP "dpc" 12 +End-to-end Data Protection Capabilities, see +\fIenum nvme_id_ns_dpc\fP. +.IP "dps" 12 +End-to-end Data Protection Type Settings, see +\fIenum nvme_id_ns_dps\fP. +.IP "nmic" 12 +Namespace Multi-path I/O and Namespace Sharing Capabilities, see +\fIenum nvme_id_ns_nmic\fP. +.IP "rescap" 12 +Reservation Capabilities, see \fIenum nvme_id_ns_rescap\fP. +.IP "fpi" 12 +Format Progress Indicator, see \fIenum nvme_nd_ns_fpi\fP. +.IP "dlfeat" 12 +Deallocate Logical Block Features, see \fIenum nvme_id_ns_dlfeat\fP. +.IP "nawun" 12 +Namespace Atomic Write Unit Normal indicates the +namespace specific size of the write operation guaranteed to be +written atomically to the NVM during normal operation. +.IP "nawupf" 12 +Namespace Atomic Write Unit Power Fail indicates the +namespace specific size of the write operation guaranteed to be +written atomically to the NVM during a power fail or error +condition. +.IP "nacwu" 12 +Namespace Atomic Compare & Write Unit indicates the namespace +specific size of the write operation guaranteed to be written +atomically to the NVM for a Compare and Write fused command. +.IP "nabsn" 12 +Namespace Atomic Boundary Size Normal indicates the atomic +boundary size for this namespace for the NAWUN value. This field +is specified in logical blocks. +.IP "nabo" 12 +Namespace Atomic Boundary Offset indicates the LBA on this +namespace where the first atomic boundary starts. +.IP "nabspf" 12 +Namespace Atomic Boundary Size Power Fail indicates the atomic +boundary size for this namespace specific to the Namespace Atomic +Write Unit Power Fail value. This field is specified in logical +blocks. +.IP "noiob" 12 +Namespace Optimal I/O Boundary indicates the optimal I/O boundary +for this namespace. This field is specified in logical blocks. +The host should construct Read and Write commands that do not +cross the I/O boundary to achieve optimal performance. +.IP "nvmcap" 12 +NVM Capacity indicates the total size of the NVM allocated to +this namespace. The value is in bytes. +.IP "npwg" 12 +Namespace Preferred Write Granularity indicates the smallest +recommended write granularity in logical blocks for this +namespace. This is a 0's based value. +.IP "npwa" 12 +Namespace Preferred Write Alignment indicates the recommended +write alignment in logical blocks for this namespace. This is a +0's based value. +.IP "npdg" 12 +Namespace Preferred Deallocate Granularity indicates the +recommended granularity in logical blocks for the Dataset +Management command with the Attribute - Deallocate bit. +.IP "npda" 12 +Namespace Preferred Deallocate Alignment indicates the +recommended alignment in logical blocks for the Dataset +Management command with the Attribute - Deallocate bit +.IP "nows" 12 +Namespace Optimal Write Size indicates the size in logical blocks +for optimal write performance for this namespace. This is a 0's +based value. +.IP "mssrl" 12 +Maximum Single Source Range Length indicates the maximum number +of logical blocks that may be specified in each valid Source Range +field of a Copy command. +.IP "mcl" 12 +Maximum Copy Length indicates the maximum number of logical +blocks that may be specified in a Copy command. +.IP "msrc" 12 +Maximum Source Range Count indicates the maximum number of Source +Range entries that may be used to specify source data in a Copy +command. This is a 0’s based value. +.IP "rsvd81" 12 +Reserved +.IP "nulbaf" 12 +Number of Unique Capability LBA Formats defines the number of +supported user data size and metadata size combinations supported +by the namespace that may not share the same capabilities. LBA +formats shall be allocated in order and packed sequentially. +.IP "rsvd83" 12 +Reserved +.IP "anagrpid" 12 +ANA Group Identifier indicates the ANA Group Identifier of the +ANA group of which the namespace is a member. +.IP "rsvd96" 12 +Reserved +.IP "nsattr" 12 +Namespace Attributes, see \fIenum nvme_id_ns_attr\fP. +.IP "nvmsetid" 12 +NVM Set Identifier indicates the NVM Set with which this +namespace is associated. +.IP "endgid" 12 +Endurance Group Identifier indicates the Endurance Group with +which this namespace is associated. +.IP "nguid" 12 +Namespace Globally Unique Identifier contains a 128-bit value +that is globally unique and assigned to the namespace when the +namespace is created. This field remains fixed throughout the +life of the namespace and is preserved across namespace and +controller operations +.IP "eui64" 12 +IEEE Extended Unique Identifier contains a 64-bit IEEE Extended +Unique Identifier (EUI-64) that is globally unique and assigned +to the namespace when the namespace is created. This field +remains fixed throughout the life of the namespace and is +preserved across namespace and controller operations +.IP "lbaf" 12 +LBA Format, see \fIstruct nvme_lbaf\fP. +.IP "lbstm" 12 +Logical Block Storage Tag Mask for end-to-end protection +.IP "vs" 12 +Vendor Specific diff --git a/doc/man/nvme_id_ns_attr.2 b/doc/man/nvme_id_ns_attr.2 new file mode 100644 index 0000000..05bd554 --- /dev/null +++ b/doc/man/nvme_id_ns_attr.2 @@ -0,0 +1,14 @@ +.TH "libnvme" 9 "enum nvme_id_ns_attr" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ns_attr \- Specifies attributes of the namespace. +.SH SYNOPSIS +enum nvme_id_ns_attr { +.br +.BI " NVME_NS_NSATTR_WRITE_PROTECTED" + +}; +.SH Constants +.IP "NVME_NS_NSATTR_WRITE_PROTECTED" 12 +If set, then the namespace is currently +write protected and all write access to the +namespace shall fail. diff --git a/doc/man/nvme_id_ns_dlfeat.2 b/doc/man/nvme_id_ns_dlfeat.2 new file mode 100644 index 0000000..2dabf24 --- /dev/null +++ b/doc/man/nvme_id_ns_dlfeat.2 @@ -0,0 +1,50 @@ +.TH "libnvme" 9 "enum nvme_id_ns_dlfeat" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ns_dlfeat \- This field indicates information about features that affect deallocating logical blocks for this namespace. +.SH SYNOPSIS +enum nvme_id_ns_dlfeat { +.br +.BI " NVME_NS_DLFEAT_RB" +, +.br +.br +.BI " NVME_NS_DLFEAT_RB_NR" +, +.br +.br +.BI " NVME_NS_DLFEAT_RB_ALL_0S" +, +.br +.br +.BI " NVME_NS_DLFEAT_RB_ALL_FS" +, +.br +.br +.BI " NVME_NS_DLFEAT_WRITE_ZEROES" +, +.br +.br +.BI " NVME_NS_DLFEAT_CRC_GUARD" + +}; +.SH Constants +.IP "NVME_NS_DLFEAT_RB" 12 +Mask to get the value of the read behavior +.IP "NVME_NS_DLFEAT_RB_NR" 12 +Read behvaior is not reported +.IP "NVME_NS_DLFEAT_RB_ALL_0S" 12 +A deallocated logical block returns all bytes +cleared to 0h. +.IP "NVME_NS_DLFEAT_RB_ALL_FS" 12 +A deallocated logical block returns all bytes +set to FFh. +.IP "NVME_NS_DLFEAT_WRITE_ZEROES" 12 +If set, indicates that the controller supports +the Deallocate bit in the Write Zeroes command +for this namespace. +.IP "NVME_NS_DLFEAT_CRC_GUARD" 12 +If set, indicates that the Guard field for +deallocated logical blocks that contain +protection information is set to the CRC for +the value read from the deallocated logical +block and its metadata diff --git a/doc/man/nvme_id_ns_dpc.2 b/doc/man/nvme_id_ns_dpc.2 new file mode 100644 index 0000000..2ccfca9 --- /dev/null +++ b/doc/man/nvme_id_ns_dpc.2 @@ -0,0 +1,43 @@ +.TH "libnvme" 9 "enum nvme_id_ns_dpc" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ns_dpc \- This field indicates the capabilities for the end-to-end data protection feature. +.SH SYNOPSIS +enum nvme_id_ns_dpc { +.br +.BI " NVME_NS_DPC_PI_TYPE1" +, +.br +.br +.BI " NVME_NS_DPC_PI_TYPE2" +, +.br +.br +.BI " NVME_NS_DPC_PI_TYPE3" +, +.br +.br +.BI " NVME_NS_DPC_PI_FIRST" +, +.br +.br +.BI " NVME_NS_DPC_PI_LAST" + +}; +.SH Constants +.IP "NVME_NS_DPC_PI_TYPE1" 12 +If set, indicates that the namespace supports +Protection Information Type 1. +.IP "NVME_NS_DPC_PI_TYPE2" 12 +If set, indicates that the namespace supports +Protection Information Type 2. +.IP "NVME_NS_DPC_PI_TYPE3" 12 +If set, indicates that the namespace supports +Protection Information Type 3. +.IP "NVME_NS_DPC_PI_FIRST" 12 +If set, indicates that the namespace supports +protection information transferred as the first eight +bytes of metadata. +.IP "NVME_NS_DPC_PI_LAST" 12 +If set, indicates that the namespace supports +protection information transferred as the last eight +bytes of metadata. diff --git a/doc/man/nvme_id_ns_dps.2 b/doc/man/nvme_id_ns_dps.2 new file mode 100644 index 0000000..f171054 --- /dev/null +++ b/doc/man/nvme_id_ns_dps.2 @@ -0,0 +1,44 @@ +.TH "libnvme" 9 "enum nvme_id_ns_dps" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ns_dps \- This field indicates the Type settings for the end-to-end data protection feature. +.SH SYNOPSIS +enum nvme_id_ns_dps { +.br +.BI " NVME_NS_DPS_PI_NONE" +, +.br +.br +.BI " NVME_NS_DPS_PI_TYPE1" +, +.br +.br +.BI " NVME_NS_DPS_PI_TYPE2" +, +.br +.br +.BI " NVME_NS_DPS_PI_TYPE3" +, +.br +.br +.BI " NVME_NS_DPS_PI_MASK" +, +.br +.br +.BI " NVME_NS_DPS_PI_FIRST" + +}; +.SH Constants +.IP "NVME_NS_DPS_PI_NONE" 12 +Protection information is not enabled +.IP "NVME_NS_DPS_PI_TYPE1" 12 +Protection information is enabled, Type 1 +.IP "NVME_NS_DPS_PI_TYPE2" 12 +Protection information is enabled, Type 2 +.IP "NVME_NS_DPS_PI_TYPE3" 12 +Protection information is enabled, Type 3 +.IP "NVME_NS_DPS_PI_MASK" 12 +Mask to get the value of the PI type +.IP "NVME_NS_DPS_PI_FIRST" 12 +If set, indicates that the protection information, if +enabled, is transferred as the first eight bytes of +metadata. diff --git a/doc/man/nvme_id_ns_flbas.2 b/doc/man/nvme_id_ns_flbas.2 new file mode 100644 index 0000000..e2b54af --- /dev/null +++ b/doc/man/nvme_id_ns_flbas.2 @@ -0,0 +1,35 @@ +.TH "libnvme" 9 "enum nvme_id_ns_flbas" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ns_flbas \- This field indicates the LBA data size & metadata size combination that the namespace has been formatted with +.SH SYNOPSIS +enum nvme_id_ns_flbas { +.br +.BI " NVME_NS_FLBAS_LOWER_MASK" +, +.br +.br +.BI " NVME_NS_FLBAS_META_EXT" +, +.br +.br +.BI " NVME_NS_FLBAS_HIGHER_MASK" + +}; +.SH Constants +.IP "NVME_NS_FLBAS_LOWER_MASK" 12 +Mask to get the index of one of the supported +LBA Formats's least significant +4bits indicated in +:c:type:`struct nvme_id_ns <nvme_id_ns>`.lbaf. +.IP "NVME_NS_FLBAS_META_EXT" 12 +Applicable only if format contains metadata. If +this bit is set, indicates that the metadata is +transferred at the end of the data LBA, creating an +extended data LBA. If cleared, indicates that all +of the metadata for a command is transferred as a +separate contiguous buffer of data. +.IP "NVME_NS_FLBAS_HIGHER_MASK" 12 +Mask to get the index of one of +the supported LBA Formats's most significant +2bits indicated in +:c:type:`struct nvme_id_ns <nvme_id_ns>`.lbaf. diff --git a/doc/man/nvme_id_ns_granularity_desc.2 b/doc/man/nvme_id_ns_granularity_desc.2 new file mode 100644 index 0000000..8c7c259 --- /dev/null +++ b/doc/man/nvme_id_ns_granularity_desc.2 @@ -0,0 +1,19 @@ +.TH "libnvme" 9 "struct nvme_id_ns_granularity_desc" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_id_ns_granularity_desc \- +.SH SYNOPSIS +struct nvme_id_ns_granularity_desc { +.br +.BI " __le64 nszegran;" +.br +.BI " __le64 ncapgran;" +.br +.BI " +}; +.br + +.SH Members +.IP "nszegran" 12 +Namespace Size Granularity +.IP "ncapgran" 12 +Namespace Capacity Granularity diff --git a/doc/man/nvme_id_ns_granularity_list.2 b/doc/man/nvme_id_ns_granularity_list.2 new file mode 100644 index 0000000..375974e --- /dev/null +++ b/doc/man/nvme_id_ns_granularity_list.2 @@ -0,0 +1,31 @@ +.TH "libnvme" 9 "struct nvme_id_ns_granularity_list" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_id_ns_granularity_list \- +.SH SYNOPSIS +struct nvme_id_ns_granularity_list { +.br +.BI " __le32 attributes;" +.br +.BI " __u8 num_descriptors;" +.br +.BI " __u8 rsvd5[27];" +.br +.BI " struct nvme_id_ns_granularity_desc entry[NVME_ID_ND_DESCRIPTOR_MAX];" +.br +.BI " __u8 rsvd288[3808];" +.br +.BI " +}; +.br + +.SH Members +.IP "attributes" 12 +Namespace Granularity Attributes +.IP "num_descriptors" 12 +Number of Descriptors +.IP "rsvd5" 12 +reserved +.IP "entry" 12 +Namespace Granularity Descriptor +.IP "rsvd288" 12 +reserved diff --git a/doc/man/nvme_id_ns_mc.2 b/doc/man/nvme_id_ns_mc.2 new file mode 100644 index 0000000..774742f --- /dev/null +++ b/doc/man/nvme_id_ns_mc.2 @@ -0,0 +1,21 @@ +.TH "libnvme" 9 "enum nvme_id_ns_mc" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ns_mc \- This field indicates the capabilities for metadata. +.SH SYNOPSIS +enum nvme_id_ns_mc { +.br +.BI " NVME_NS_MC_EXTENDED" +, +.br +.br +.BI " NVME_NS_MC_SEPARATE" + +}; +.SH Constants +.IP "NVME_NS_MC_EXTENDED" 12 +If set, indicates the namespace supports the metadata +being transferred as part of a separate buffer that is +specified in the Metadata Pointer. +.IP "NVME_NS_MC_SEPARATE" 12 +If set, indicates that the namespace supports the +metadata being transferred as part of an extended data LBA. diff --git a/doc/man/nvme_id_ns_nmic.2 b/doc/man/nvme_id_ns_nmic.2 new file mode 100644 index 0000000..9f15b41 --- /dev/null +++ b/doc/man/nvme_id_ns_nmic.2 @@ -0,0 +1,13 @@ +.TH "libnvme" 9 "enum nvme_id_ns_nmic" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ns_nmic \- This field specifies multi-path I/O and namespace sharing capabilities of the namespace. +.SH SYNOPSIS +enum nvme_id_ns_nmic { +.br +.BI " NVME_NS_NMIC_SHARED" + +}; +.SH Constants +.IP "NVME_NS_NMIC_SHARED" 12 +If set, then the namespace may be attached to two or +more controllers in the NVM subsystem concurrently diff --git a/doc/man/nvme_id_ns_rescap.2 b/doc/man/nvme_id_ns_rescap.2 new file mode 100644 index 0000000..63fc83e --- /dev/null +++ b/doc/man/nvme_id_ns_rescap.2 @@ -0,0 +1,62 @@ +.TH "libnvme" 9 "enum nvme_id_ns_rescap" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_ns_rescap \- This field indicates the reservation capabilities of the namespace. +.SH SYNOPSIS +enum nvme_id_ns_rescap { +.br +.BI " NVME_NS_RESCAP_PTPL" +, +.br +.br +.BI " NVME_NS_RESCAP_WE" +, +.br +.br +.BI " NVME_NS_RESCAP_EA" +, +.br +.br +.BI " NVME_NS_RESCAP_WERO" +, +.br +.br +.BI " NVME_NS_RESCAP_EARO" +, +.br +.br +.BI " NVME_NS_RESCAP_WEAR" +, +.br +.br +.BI " NVME_NS_RESCAP_EAAR" +, +.br +.br +.BI " NVME_NS_RESCAP_IEK_13" + +}; +.SH Constants +.IP "NVME_NS_RESCAP_PTPL" 12 +If set, indicates that the namespace supports the +Persist Through Power Loss capability. +.IP "NVME_NS_RESCAP_WE" 12 +If set, indicates that the namespace supports the +Write Exclusive reservation type. +.IP "NVME_NS_RESCAP_EA" 12 +If set, indicates that the namespace supports the +Exclusive Access reservation type. +.IP "NVME_NS_RESCAP_WERO" 12 +If set, indicates that the namespace supports the +Write Exclusive - Registrants Only reservation type. +.IP "NVME_NS_RESCAP_EARO" 12 +If set, indicates that the namespace supports the +Exclusive Access - Registrants Only reservation type. +.IP "NVME_NS_RESCAP_WEAR" 12 +If set, indicates that the namespace supports the +Write Exclusive - All Registrants reservation type. +.IP "NVME_NS_RESCAP_EAAR" 12 +If set, indicates that the namespace supports the +Exclusive Access - All Registrants reservation type. +.IP "NVME_NS_RESCAP_IEK_13" 12 +If set, indicates that Ignore Existing Key is used +as defined in revision 1.3 or later of this specification. diff --git a/doc/man/nvme_id_nsfeat.2 b/doc/man/nvme_id_nsfeat.2 new file mode 100644 index 0000000..3c5c9ec --- /dev/null +++ b/doc/man/nvme_id_nsfeat.2 @@ -0,0 +1,50 @@ +.TH "libnvme" 9 "enum nvme_id_nsfeat" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_nsfeat \- This field defines features of the namespace. +.SH SYNOPSIS +enum nvme_id_nsfeat { +.br +.BI " NVME_NS_FEAT_THIN" +, +.br +.br +.BI " NVME_NS_FEAT_NATOMIC" +, +.br +.br +.BI " NVME_NS_FEAT_DULBE" +, +.br +.br +.BI " NVME_NS_FEAT_ID_REUSE" +, +.br +.br +.BI " NVME_NS_FEAT_IO_OPT" + +}; +.SH Constants +.IP "NVME_NS_FEAT_THIN" 12 +If set, indicates that the namespace supports thin +provisioning. Specifically, the Namespace Capacity +reported may be less than the Namespace Size. +.IP "NVME_NS_FEAT_NATOMIC" 12 +If set, indicates that the fields NAWUN, NAWUPF, and +NACWU are defined for this namespace and should be +used by the host for this namespace instead of the +AWUN, AWUPF, and ACWU fields in the Identify +Controller data structure. +.IP "NVME_NS_FEAT_DULBE" 12 +If set, indicates that the controller supports the +Deallocated or Unwritten Logical Block error for +this namespace. +.IP "NVME_NS_FEAT_ID_REUSE" 12 +If set, indicates that the value in the NGUID field +for this namespace, if non- zero, is never reused by +the controller and that the value in the EUI64 field +for this namespace, if non-zero, is never reused by +the controller. +.IP "NVME_NS_FEAT_IO_OPT" 12 +If set, indicates that the fields NPWG, NPWA, NPDG, +NPDA, and NOWS are defined for this namespace and +should be used by the host for I/O optimization diff --git a/doc/man/nvme_id_nvmset_list.2 b/doc/man/nvme_id_nvmset_list.2 new file mode 100644 index 0000000..6907ea7 --- /dev/null +++ b/doc/man/nvme_id_nvmset_list.2 @@ -0,0 +1,23 @@ +.TH "libnvme" 9 "struct nvme_id_nvmset_list" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_id_nvmset_list \- +.SH SYNOPSIS +struct nvme_id_nvmset_list { +.br +.BI " __u8 nid;" +.br +.BI " __u8 rsvd1[127];" +.br +.BI " struct nvme_nvmset_attr ent[NVME_ID_NVMSET_LIST_MAX];" +.br +.BI " +}; +.br + +.SH Members +.IP "nid" 12 +Nvmset id +.IP "rsvd1" 12 +Reserved +.IP "ent" 12 +nvmset id list diff --git a/doc/man/nvme_id_psd.2 b/doc/man/nvme_id_psd.2 new file mode 100644 index 0000000..435d380 --- /dev/null +++ b/doc/man/nvme_id_psd.2 @@ -0,0 +1,95 @@ +.TH "libnvme" 9 "struct nvme_id_psd" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_id_psd \- +.SH SYNOPSIS +struct nvme_id_psd { +.br +.BI " __le16 mp;" +.br +.BI " __u8 rsvd2;" +.br +.BI " __u8 flags;" +.br +.BI " __le32 enlat;" +.br +.BI " __le32 exlat;" +.br +.BI " __u8 rrt;" +.br +.BI " __u8 rrl;" +.br +.BI " __u8 rwt;" +.br +.BI " __u8 rwl;" +.br +.BI " __le16 idlp;" +.br +.BI " __u8 ips;" +.br +.BI " __u8 rsvd19;" +.br +.BI " __le16 actp;" +.br +.BI " __u8 apws;" +.br +.BI " __u8 rsvd23[9];" +.br +.BI " +}; +.br + +.SH Members +.IP "mp" 12 +Maximum Power indicates the sustained maximum power consumed by the +NVM subsystem in this power state. The power in Watts is equal to +the value in this field multiplied by the scale specified in the Max +Power Scale bit (see \fIenum nvme_psd_flags\fP). A value of 0 indicates +Maximum Power is not reported. +.IP "rsvd2" 12 +Reserved +.IP "flags" 12 +Additional decoding flags, see \fIenum nvme_psd_flags\fP. +.IP "enlat" 12 +Entry Latency indicates the maximum latency in microseconds +associated with entering this power state. A value of 0 indicates +Entry Latency is not reported. +.IP "exlat" 12 +Exit Latency indicates the maximum latency in microseconds +associated with exiting this power state. A value of 0 indicates +Exit Latency is not reported. +.IP "rrt" 12 +Relative Read Throughput indicates the read throughput rank +associated with this power state relative to others. The value in +this is less than the number of supported power states. +.IP "rrl" 12 +Relative Reade Latency indicates the read latency rank associated +with this power state relative to others. The value in this field is +less than the number of supported power states. +.IP "rwt" 12 +Relative Write Throughput indicates write throughput rank associated +with this power state relative to others. The value in this field is +less than the number of supported power states +.IP "rwl" 12 +Relative Write Latency indicates the write latency rank associated +with this power state relative to others. The value in this field is +less than the number of supported power states +.IP "idlp" 12 +Idle Power indicates the typical power consumed by the NVM +subsystem over 30 seconds in this power state when idle. +.IP "ips" 12 +Idle Power Scale indicates the scale for \fIstruct nvme_id_psd\fP.idlp, +see \fIenum nvme_psd_ps\fP for decoding this field. +.IP "rsvd19" 12 +Reserved +.IP "actp" 12 +Active Power indicates the largest average power consumed by the +NVM subsystem over a 10 second period in this power state with +the workload indicated in the Active Power Workload field. +.IP "apws" 12 +Bits 7-6: Active Power Scale(APS) indicates the scale for the \fIstruct +nvme_id_psd\fP.actp, see \fIenum nvme_psd_ps\fP for decoding this value. +Bits 2-0: Active Power Workload(APW) indicates the workload +used to calculate maximum power for this power state. +See \fIenum nvme_psd_workload\fP for decoding this field. +.IP "rsvd23" 12 +Reserved diff --git a/doc/man/nvme_id_uuid.2 b/doc/man/nvme_id_uuid.2 new file mode 100644 index 0000000..01326e7 --- /dev/null +++ b/doc/man/nvme_id_uuid.2 @@ -0,0 +1,26 @@ +.TH "libnvme" 9 "enum nvme_id_uuid" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_id_uuid \- +.SH SYNOPSIS +enum nvme_id_uuid { +.br +.BI " NVME_ID_UUID_HDR_ASSOCIATION_MASK" +, +.br +.br +.BI " NVME_ID_UUID_ASSOCIATION_NONE" +, +.br +.br +.BI " NVME_ID_UUID_ASSOCIATION_VENDOR" +, +.br +.br +.BI " NVME_ID_UUID_ASSOCIATION_SUBSYSTEM_VENDOR" + +}; +.SH Constants +.IP "NVME_ID_UUID_HDR_ASSOCIATION_MASK" 12 +.IP "NVME_ID_UUID_ASSOCIATION_NONE" 12 +.IP "NVME_ID_UUID_ASSOCIATION_VENDOR" 12 +.IP "NVME_ID_UUID_ASSOCIATION_SUBSYSTEM_VENDOR" 12 diff --git a/doc/man/nvme_id_uuid_list.2 b/doc/man/nvme_id_uuid_list.2 new file mode 100644 index 0000000..8aca721 --- /dev/null +++ b/doc/man/nvme_id_uuid_list.2 @@ -0,0 +1,19 @@ +.TH "libnvme" 9 "struct nvme_id_uuid_list" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_id_uuid_list \- +.SH SYNOPSIS +struct nvme_id_uuid_list { +.br +.BI " __u8 rsvd0[32];" +.br +.BI " struct nvme_id_uuid_list_entry entry[NVME_ID_UUID_LIST_MAX];" +.br +.BI " +}; +.br + +.SH Members +.IP "rsvd0" 12 +reserved +.IP "entry" 12 +UUID list entry diff --git a/doc/man/nvme_id_uuid_list_entry.2 b/doc/man/nvme_id_uuid_list_entry.2 new file mode 100644 index 0000000..ca2d528 --- /dev/null +++ b/doc/man/nvme_id_uuid_list_entry.2 @@ -0,0 +1,23 @@ +.TH "libnvme" 9 "struct nvme_id_uuid_list_entry" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_id_uuid_list_entry \- +.SH SYNOPSIS +struct nvme_id_uuid_list_entry { +.br +.BI " __u8 header;" +.br +.BI " __u8 rsvd1[15];" +.br +.BI " __u8 uuid[16];" +.br +.BI " +}; +.br + +.SH Members +.IP "header" 12 +UUID Lists Entry Header +.IP "rsvd1" 12 +reserved +.IP "uuid" 12 +128-bit Universally Unique Identifier diff --git a/doc/man/nvme_identify.2 b/doc/man/nvme_identify.2 new file mode 100644 index 0000000..527185e --- /dev/null +++ b/doc/man/nvme_identify.2 @@ -0,0 +1,15 @@ +.TH "nvme_identify" 9 "nvme_identify" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_identify \- Send the NVMe Identify command +.SH SYNOPSIS +.B "int" nvme_identify +.BI "(struct nvme_identify_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_identify_args\fP argument structure +.SH "DESCRIPTION" +The Identify command returns a data buffer that describes information about +the NVM subsystem, the controller or the namespace(s). +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_identify_active_ns_list.2 b/doc/man/nvme_identify_active_ns_list.2 new file mode 100644 index 0000000..73eba7c --- /dev/null +++ b/doc/man/nvme_identify_active_ns_list.2 @@ -0,0 +1,24 @@ +.TH "nvme_identify_active_ns_list" 9 "nvme_identify_active_ns_list" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_identify_active_ns_list \- Retrieves active namespaces id list +.SH SYNOPSIS +.B "int" nvme_identify_active_ns_list +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "struct nvme_ns_list *list " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Return namespaces greater than this identifer +.IP "list" 12 +User space destination address to transfer the data +.SH "DESCRIPTION" +A list of 1024 namespace IDs is returned to the host containing NSIDs in +increasing order that are greater than the value specified in the Namespace +Identifier (nsid) field of the command. + +See \fIstruct nvme_ns_list\fP for the definition of the returned structure. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_identify_active_ns_list_csi.2 b/doc/man/nvme_identify_active_ns_list_csi.2 new file mode 100644 index 0000000..01c49a9 --- /dev/null +++ b/doc/man/nvme_identify_active_ns_list_csi.2 @@ -0,0 +1,28 @@ +.TH "nvme_identify_active_ns_list_csi" 9 "nvme_identify_active_ns_list_csi" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_identify_active_ns_list_csi \- Active namespace ID list associated with a specified I/O command set +.SH SYNOPSIS +.B "int" nvme_identify_active_ns_list_csi +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "enum nvme_csi csi " "," +.BI "struct nvme_ns_list *ns_list " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Return namespaces greater than this identifier +.IP "csi" 12 +Command Set Identifier +.IP "ns_list" 12 +User space destination address to transfer the data +.SH "DESCRIPTION" +A list of 1024 namespace IDs is returned to the host containing active +NSIDs in increasing order that are greater than the value specified in +the Namespace Identifier (nsid) field of the command and matching the +I/O Command Set specified in the \fIcsi\fP argument. + +See \fIstruct nvme_ns_list\fP for the definition of the returned structure. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_identify_allocated_ns.2 b/doc/man/nvme_identify_allocated_ns.2 new file mode 100644 index 0000000..3927da4 --- /dev/null +++ b/doc/man/nvme_identify_allocated_ns.2 @@ -0,0 +1,18 @@ +.TH "nvme_identify_allocated_ns" 9 "nvme_identify_allocated_ns" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_identify_allocated_ns \- Same as nvme_identify_ns, but only for allocated namespaces +.SH SYNOPSIS +.B "int" nvme_identify_allocated_ns +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "struct nvme_id_ns *ns " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Namespace to identify +.IP "ns" 12 +User space destination address to transfer the data +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_identify_allocated_ns_list.2 b/doc/man/nvme_identify_allocated_ns_list.2 new file mode 100644 index 0000000..5aaf6fc --- /dev/null +++ b/doc/man/nvme_identify_allocated_ns_list.2 @@ -0,0 +1,24 @@ +.TH "nvme_identify_allocated_ns_list" 9 "nvme_identify_allocated_ns_list" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_identify_allocated_ns_list \- Retrieves allocated namespace id list +.SH SYNOPSIS +.B "int" nvme_identify_allocated_ns_list +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "struct nvme_ns_list *list " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Return namespaces greater than this identifer +.IP "list" 12 +User space destination address to transfer the data +.SH "DESCRIPTION" +A list of 1024 namespace IDs is returned to the host containing NSIDs in +increasing order that are greater than the value specified in the Namespace +Identifier (nsid) field of the command. + +See \fIstruct nvme_ns_list\fP for the definition of the returned structure. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_identify_allocated_ns_list_csi.2 b/doc/man/nvme_identify_allocated_ns_list_csi.2 new file mode 100644 index 0000000..447be6c --- /dev/null +++ b/doc/man/nvme_identify_allocated_ns_list_csi.2 @@ -0,0 +1,28 @@ +.TH "nvme_identify_allocated_ns_list_csi" 9 "nvme_identify_allocated_ns_list_csi" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_identify_allocated_ns_list_csi \- Allocated namespace ID list associated with a specified I/O command set +.SH SYNOPSIS +.B "int" nvme_identify_allocated_ns_list_csi +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "enum nvme_csi csi " "," +.BI "struct nvme_ns_list *ns_list " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Return namespaces greater than this identifier +.IP "csi" 12 +Command Set Identifier +.IP "ns_list" 12 +User space destination address to transfer the data +.SH "DESCRIPTION" +A list of 1024 namespace IDs is returned to the host containing allocated +NSIDs in increasing order that are greater than the value specified in +the \fInsid\fP field of the command and matching the I/O Command Set +specified in the \fIcsi\fP argument. + +See \fIstruct nvme_ns_list\fP for the definition of the returned structure. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_identify_args.2 b/doc/man/nvme_identify_args.2 new file mode 100644 index 0000000..58b9667 --- /dev/null +++ b/doc/man/nvme_identify_args.2 @@ -0,0 +1,55 @@ +.TH "libnvme" 9 "struct nvme_identify_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_identify_args \- Arguments for the NVMe Identify command +.SH SYNOPSIS +struct nvme_identify_args { +.br +.BI " __u32 *result;" +.br +.BI " void *data;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " enum nvme_identify_cns cns;" +.br +.BI " enum nvme_csi csi;" +.br +.BI " __u32 nsid;" +.br +.BI " __u16 cntid;" +.br +.BI " __u16 cns_specific_id;" +.br +.BI " __u8 uuidx;" +.br +.BI " +}; +.br + +.SH Members +.IP "result" 12 +The command completion result from CQE dword0 +.IP "data" 12 +User space destination address to transfer the data +.IP "args_size" 12 +Size of \fIstruct nvme_identify_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms (0 for default timeout) +.IP "cns" 12 +The Controller or Namespace structure, see \fIenum\fP nvme_identify_cns +.IP "csi" 12 +Command Set Identifier +.IP "nsid" 12 +Namespace identifier, if applicable +.IP "cntid" 12 +The Controller Identifier, if applicable +.IP "cns_specific_id" 12 +Identifier that is required for a particular CNS value +.IP "uuidx" 12 +UUID Index if controller supports this id selection method diff --git a/doc/man/nvme_identify_cns.2 b/doc/man/nvme_identify_cns.2 new file mode 100644 index 0000000..1b5b4f2 --- /dev/null +++ b/doc/man/nvme_identify_cns.2 @@ -0,0 +1,162 @@ +.TH "libnvme" 9 "enum nvme_identify_cns" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_identify_cns \- +.SH SYNOPSIS +enum nvme_identify_cns { +.br +.BI " NVME_IDENTIFY_CNS_NS" +, +.br +.br +.BI " NVME_IDENTIFY_CNS_CTRL" +, +.br +.br +.BI " NVME_IDENTIFY_CNS_NS_ACTIVE_LIST" +, +.br +.br +.BI " NVME_IDENTIFY_CNS_NS_DESC_LIST" +, +.br +.br +.BI " NVME_IDENTIFY_CNS_NVMSET_LIST" +, +.br +.br +.BI " NVME_IDENTIFY_CNS_CSI_NS" +, +.br +.br +.BI " NVME_IDENTIFY_CNS_CSI_CTRL" +, +.br +.br +.BI " NVME_IDENTIFY_CNS_CSI_NS_ACTIVE_LIST" +, +.br +.br +.BI " NVME_IDENTIFY_CNS_CSI_INDEPENDENT_ID_NS" +, +.br +.br +.BI " NVME_IDENTIFY_CNS_NS_USER_DATA_FORMAT" +, +.br +.br +.BI " NVME_IDENTIFY_CNS_CSI_NS_USER_DATA_FORMAT" +, +.br +.br +.BI " NVME_IDENTIFY_CNS_ALLOCATED_NS_LIST" +, +.br +.br +.BI " NVME_IDENTIFY_CNS_ALLOCATED_NS" +, +.br +.br +.BI " NVME_IDENTIFY_CNS_NS_CTRL_LIST" +, +.br +.br +.BI " NVME_IDENTIFY_CNS_CTRL_LIST" +, +.br +.br +.BI " NVME_IDENTIFY_CNS_PRIMARY_CTRL_CAP" +, +.br +.br +.BI " NVME_IDENTIFY_CNS_SECONDARY_CTRL_LIST" +, +.br +.br +.BI " NVME_IDENTIFY_CNS_NS_GRANULARITY" +, +.br +.br +.BI " NVME_IDENTIFY_CNS_UUID_LIST" +, +.br +.br +.BI " NVME_IDENTIFY_CNS_DOMAIN_LIST" +, +.br +.br +.BI " NVME_IDENTIFY_CNS_ENDURANCE_GROUP_ID" +, +.br +.br +.BI " NVME_IDENTIFY_CNS_CSI_ALLOCATED_NS_LIST" +, +.br +.br +.BI " NVME_IDENTIFY_CNS_CSI_ID_NS_DATA_STRUCTURE" +, +.br +.br +.BI " NVME_IDENTIFY_CNS_COMMAND_SET_STRUCTURE" + +}; +.SH Constants +.IP "NVME_IDENTIFY_CNS_NS" 12 +Identify Namespace data structure +.IP "NVME_IDENTIFY_CNS_CTRL" 12 +Identify Controller data structur +.IP "NVME_IDENTIFY_CNS_NS_ACTIVE_LIST" 12 +Active Namespace ID list +.IP "NVME_IDENTIFY_CNS_NS_DESC_LIST" 12 +Namespace Identification Descriptor list +.IP "NVME_IDENTIFY_CNS_NVMSET_LIST" 12 +NVM Set List +.IP "NVME_IDENTIFY_CNS_CSI_NS" 12 +I/O Command Set specific Identify +Namespace data structure +.IP "NVME_IDENTIFY_CNS_CSI_CTRL" 12 +I/O Command Set specific Identify +Controller data structure +.IP "NVME_IDENTIFY_CNS_CSI_NS_ACTIVE_LIST" 12 +Active Namespace ID list associated +with the specified I/O Command Set +.IP "NVME_IDENTIFY_CNS_CSI_INDEPENDENT_ID_NS" 12 +I/O Command Set Independent Identify +Namespace data structure +.IP "NVME_IDENTIFY_CNS_NS_USER_DATA_FORMAT" 12 +-- undescribed -- +.IP "NVME_IDENTIFY_CNS_CSI_NS_USER_DATA_FORMAT" 12 +-- undescribed -- +.IP "NVME_IDENTIFY_CNS_ALLOCATED_NS_LIST" 12 +Allocated Namespace ID list +.IP "NVME_IDENTIFY_CNS_ALLOCATED_NS" 12 +Identify Namespace data structure for +the specified allocated NSID +.IP "NVME_IDENTIFY_CNS_NS_CTRL_LIST" 12 +Controller List of controllers attached +to the specified NSID +.IP "NVME_IDENTIFY_CNS_CTRL_LIST" 12 +Controller List of controllers that exist +in the NVM subsystem +.IP "NVME_IDENTIFY_CNS_PRIMARY_CTRL_CAP" 12 +Primary Controller Capabilities data +structure for the specified primary controller +.IP "NVME_IDENTIFY_CNS_SECONDARY_CTRL_LIST" 12 +Secondary Controller list of controllers +associated with the primary controller +processing the command +.IP "NVME_IDENTIFY_CNS_NS_GRANULARITY" 12 +A Namespace Granularity Lis +.IP "NVME_IDENTIFY_CNS_UUID_LIST" 12 +A UUID List +.IP "NVME_IDENTIFY_CNS_DOMAIN_LIST" 12 +Domain List +.IP "NVME_IDENTIFY_CNS_ENDURANCE_GROUP_ID" 12 +Endurance Group List +.IP "NVME_IDENTIFY_CNS_CSI_ALLOCATED_NS_LIST" 12 +I/O Command Set specific Allocated Namespace +ID list +.IP "NVME_IDENTIFY_CNS_CSI_ID_NS_DATA_STRUCTURE" 12 +I/O Command Set specific ID Namespace +Data Structure for Allocated Namespace ID +.IP "NVME_IDENTIFY_CNS_COMMAND_SET_STRUCTURE" 12 +Base Specification 2.0a section 5.17.2.21 diff --git a/doc/man/nvme_identify_ctrl.2 b/doc/man/nvme_identify_ctrl.2 new file mode 100644 index 0000000..dce2bf1 --- /dev/null +++ b/doc/man/nvme_identify_ctrl.2 @@ -0,0 +1,19 @@ +.TH "nvme_identify_ctrl" 9 "nvme_identify_ctrl" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_identify_ctrl \- Retrieves nvme identify controller +.SH SYNOPSIS +.B "int" nvme_identify_ctrl +.BI "(int fd " "," +.BI "struct nvme_id_ctrl *id " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "id" 12 +User space destination address to transfer the data, +.SH "DESCRIPTION" +Sends nvme identify with CNS value NVME_IDENTIFY_CNS_CTRL. + +See \fIstruct nvme_id_ctrl\fP for details on the data returned. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_identify_ctrl_csi.2 b/doc/man/nvme_identify_ctrl_csi.2 new file mode 100644 index 0000000..60572eb --- /dev/null +++ b/doc/man/nvme_identify_ctrl_csi.2 @@ -0,0 +1,22 @@ +.TH "nvme_identify_ctrl_csi" 9 "nvme_identify_ctrl_csi" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_identify_ctrl_csi \- I/O command set specific Identify Controller data +.SH SYNOPSIS +.B "int" nvme_identify_ctrl_csi +.BI "(int fd " "," +.BI "enum nvme_csi csi " "," +.BI "void *data " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "csi" 12 +Command Set Identifier +.IP "data" 12 +User space destination address to transfer the data +.SH "DESCRIPTION" +An I/O Command Set specific Identify Controller data structure is returned +to the host for the controller processing the command. The specific Identify +Controller data structure to be returned is specified by \fIcsi\fP. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_identify_ctrl_list.2 b/doc/man/nvme_identify_ctrl_list.2 new file mode 100644 index 0000000..dc2296f --- /dev/null +++ b/doc/man/nvme_identify_ctrl_list.2 @@ -0,0 +1,24 @@ +.TH "nvme_identify_ctrl_list" 9 "nvme_identify_ctrl_list" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_identify_ctrl_list \- Retrieves identify controller list +.SH SYNOPSIS +.B "int" nvme_identify_ctrl_list +.BI "(int fd " "," +.BI "__u16 cntid " "," +.BI "struct nvme_ctrl_list *cntlist " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "cntid" 12 +Starting CNTLID to return in the list +.IP "cntlist" 12 +User space destination address to transfer the data +.SH "DESCRIPTION" +Up to 2047 controller identifiers is returned containing a controller +identifier greater than or equal to the controller identifier specified in +\fIcntid\fP. + +See \fIstruct nvme_ctrl_list\fP for a definition of the structure returned. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_identify_domain_list.2 b/doc/man/nvme_identify_domain_list.2 new file mode 100644 index 0000000..58a76d8 --- /dev/null +++ b/doc/man/nvme_identify_domain_list.2 @@ -0,0 +1,25 @@ +.TH "nvme_identify_domain_list" 9 "nvme_identify_domain_list" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_identify_domain_list \- Domain list data +.SH SYNOPSIS +.B "int" nvme_identify_domain_list +.BI "(int fd " "," +.BI "__u16 domid " "," +.BI "struct nvme_id_domain_list *list " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "domid" 12 +Domain ID +.IP "list" 12 +User space destiantion address to transfer data +.SH "DESCRIPTION" +A list of 31 domain IDs is returned to the host containing domain +attributes in increasing order that are greater than the value +specified in the \fIdomid\fP field. + +See \fIstruct nvme_identify_domain_attr\fP for the definition of the +returned structure. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_identify_endurance_group_list.2 b/doc/man/nvme_identify_endurance_group_list.2 new file mode 100644 index 0000000..5050a9e --- /dev/null +++ b/doc/man/nvme_identify_endurance_group_list.2 @@ -0,0 +1,18 @@ +.TH "nvme_identify_endurance_group_list" 9 "nvme_identify_endurance_group_list" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_identify_endurance_group_list \- Endurance group list data +.SH SYNOPSIS +.B "int" nvme_identify_endurance_group_list +.BI "(int fd " "," +.BI "__u16 endgrp_id " "," +.BI "struct nvme_id_endurance_group_list *list " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "endgrp_id" 12 +Endurance group identifier +.IP "list" 12 +Array of endurance group identifiers +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_identify_independent_identify_ns.2 b/doc/man/nvme_identify_independent_identify_ns.2 new file mode 100644 index 0000000..9dc83a0 --- /dev/null +++ b/doc/man/nvme_identify_independent_identify_ns.2 @@ -0,0 +1,22 @@ +.TH "nvme_identify_independent_identify_ns" 9 "nvme_identify_independent_identify_ns" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_identify_independent_identify_ns \- I/O command set independent Identify namespace data +.SH SYNOPSIS +.B "int" nvme_identify_independent_identify_ns +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "struct nvme_id_independent_id_ns *ns " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Return namespaces greater than this identifier +.IP "ns" 12 +I/O Command Set Independent Identify Namespace data +structure +.SH "DESCRIPTION" +The I/O command set independent Identify namespace data structure for +the namespace identified with \fIns\fP is returned to the host. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_identify_iocs.2 b/doc/man/nvme_identify_iocs.2 new file mode 100644 index 0000000..5255ae4 --- /dev/null +++ b/doc/man/nvme_identify_iocs.2 @@ -0,0 +1,21 @@ +.TH "nvme_identify_iocs" 9 "nvme_identify_iocs" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_identify_iocs \- I/O command set data structure +.SH SYNOPSIS +.B "int" nvme_identify_iocs +.BI "(int fd " "," +.BI "__u16 cntlid " "," +.BI "struct nvme_id_iocs *iocs " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "cntlid" 12 +Controller ID +.IP "iocs" 12 +User space destination address to transfer the data +.SH "DESCRIPTION" +Retrieves list of the controller's supported io command set vectors. See +\fIstruct nvme_id_iocs\fP. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_identify_iocs_ns_csi_user_data_format.2 b/doc/man/nvme_identify_iocs_ns_csi_user_data_format.2 new file mode 100644 index 0000000..86e1c21 --- /dev/null +++ b/doc/man/nvme_identify_iocs_ns_csi_user_data_format.2 @@ -0,0 +1,28 @@ +.TH "nvme_identify_iocs_ns_csi_user_data_format" 9 "nvme_identify_iocs_ns_csi_user_data_format" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_identify_iocs_ns_csi_user_data_format \- +.SH SYNOPSIS +.B "int" nvme_identify_iocs_ns_csi_user_data_format +.BI "(int fd " "," +.BI "__u16 user_data_format " "," +.BI "__u8 uuidx " "," +.BI "enum nvme_csi csi " "," +.BI "void *data " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "user_data_format" 12 +Return namespaces capability of identifier +.IP "uuidx" 12 +UUID selection, if supported +.IP "csi" 12 +Command Set Identifier +.IP "data" 12 +-- undescribed -- +.SH "DESCRIPTION" +I/O Command Set specific Identify Namespace data structure for +the specified User Data Format index containing the namespace +capabilities for the I/O Command Set specified in the CSI field. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_identify_ns.2 b/doc/man/nvme_identify_ns.2 new file mode 100644 index 0000000..428c9cb --- /dev/null +++ b/doc/man/nvme_identify_ns.2 @@ -0,0 +1,29 @@ +.TH "nvme_identify_ns" 9 "nvme_identify_ns" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_identify_ns \- Retrieves nvme identify namespace +.SH SYNOPSIS +.B "int" nvme_identify_ns +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "struct nvme_id_ns *ns " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Namespace to identify +.IP "ns" 12 +User space destination address to transfer the data +.SH "DESCRIPTION" +If the Namespace Identifier (NSID) field specifies an active NSID, then the +Identify Namespace data structure is returned to the host for that specified +namespace. + +If the controller supports the Namespace Management capability and the NSID +field is set to NVME_NSID_ALL, then the controller returns an Identify Namespace +data structure that specifies capabilities that are common across namespaces +for this controller. + +See \fIstruct nvme_id_ns\fP for details on the structure returned. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_identify_ns_csi.2 b/doc/man/nvme_identify_ns_csi.2 new file mode 100644 index 0000000..f8ccf78 --- /dev/null +++ b/doc/man/nvme_identify_ns_csi.2 @@ -0,0 +1,27 @@ +.TH "nvme_identify_ns_csi" 9 "nvme_identify_ns_csi" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_identify_ns_csi \- I/O command set specific identify namespace data +.SH SYNOPSIS +.B "int" nvme_identify_ns_csi +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "__u8 uuidx " "," +.BI "enum nvme_csi csi " "," +.BI "void *data " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Namespace to identify +.IP "uuidx" 12 +UUID Index for differentiating vendor specific encoding +.IP "csi" 12 +Command Set Identifier +.IP "data" 12 +User space destination address to transfer the data +.SH "DESCRIPTION" +An I/O Command Set specific Identify Namespace data structre is returned +for the namespace specified in \fInsid\fP. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_identify_ns_csi_user_data_format.2 b/doc/man/nvme_identify_ns_csi_user_data_format.2 new file mode 100644 index 0000000..96fa09c --- /dev/null +++ b/doc/man/nvme_identify_ns_csi_user_data_format.2 @@ -0,0 +1,27 @@ +.TH "nvme_identify_ns_csi_user_data_format" 9 "nvme_identify_ns_csi_user_data_format" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_identify_ns_csi_user_data_format \- +.SH SYNOPSIS +.B "int" nvme_identify_ns_csi_user_data_format +.BI "(int fd " "," +.BI "__u16 user_data_format " "," +.BI "__u8 uuidx " "," +.BI "enum nvme_csi csi " "," +.BI "void *data " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "user_data_format" 12 +Return namespaces capability of identifier +.IP "uuidx" 12 +UUID selection, if supported +.IP "csi" 12 +Command Set Identifier +.IP "data" 12 +-- undescribed -- +.SH "DESCRIPTION" +Identify Namespace data structure for the specified User Data Format +index containing the namespace capabilities for the NVM Command Set. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_identify_ns_descs.2 b/doc/man/nvme_identify_ns_descs.2 new file mode 100644 index 0000000..def86ee --- /dev/null +++ b/doc/man/nvme_identify_ns_descs.2 @@ -0,0 +1,26 @@ +.TH "nvme_identify_ns_descs" 9 "nvme_identify_ns_descs" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_identify_ns_descs \- Retrieves namespace descriptor list +.SH SYNOPSIS +.B "int" nvme_identify_ns_descs +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "struct nvme_ns_id_desc *descs " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +The namespace id to retrieve destriptors +.IP "descs" 12 +User space destination address to transfer the data +.SH "DESCRIPTION" +A list of Namespace Identification Descriptor structures is returned to the +host for the namespace specified in the Namespace Identifier (NSID) field if +it is an active NSID. + +The data returned is in the form of an arrray of 'struct nvme_ns_id_desc'. + +See \fIstruct nvme_ns_id_desc\fP for the definition of the returned structure. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_identify_ns_granularity.2 b/doc/man/nvme_identify_ns_granularity.2 new file mode 100644 index 0000000..f960461 --- /dev/null +++ b/doc/man/nvme_identify_ns_granularity.2 @@ -0,0 +1,22 @@ +.TH "nvme_identify_ns_granularity" 9 "nvme_identify_ns_granularity" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_identify_ns_granularity \- Retrieves namespace granularity identification +.SH SYNOPSIS +.B "int" nvme_identify_ns_granularity +.BI "(int fd " "," +.BI "struct nvme_id_ns_granularity_list *gr_list " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "gr_list" 12 +User space destination address to transfer the data +.SH "DESCRIPTION" +If the controller supports reporting of Namespace Granularity, then a +Namespace Granularity List is returned to the host for up to sixteen +namespace granularity descriptors + +See \fIstruct nvme_id_ns_granularity_list\fP for the definition of the returned +structure. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_identify_nsid_ctrl_list.2 b/doc/man/nvme_identify_nsid_ctrl_list.2 new file mode 100644 index 0000000..3842e70 --- /dev/null +++ b/doc/man/nvme_identify_nsid_ctrl_list.2 @@ -0,0 +1,27 @@ +.TH "nvme_identify_nsid_ctrl_list" 9 "nvme_identify_nsid_ctrl_list" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_identify_nsid_ctrl_list \- Retrieves controller list attached to an nsid +.SH SYNOPSIS +.B "int" nvme_identify_nsid_ctrl_list +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "__u16 cntid " "," +.BI "struct nvme_ctrl_list *cntlist " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Return controllers that are attached to this nsid +.IP "cntid" 12 +Starting CNTLID to return in the list +.IP "cntlist" 12 +User space destination address to transfer the data +.SH "DESCRIPTION" +Up to 2047 controller identifiers are returned containing a controller +identifier greater than or equal to the controller identifier specified in +\fIcntid\fP attached to \fInsid\fP. + +See \fIstruct nvme_ctrl_list\fP for a definition of the structure returned. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 diff --git a/doc/man/nvme_identify_nvmset_list.2 b/doc/man/nvme_identify_nvmset_list.2 new file mode 100644 index 0000000..98b368a --- /dev/null +++ b/doc/man/nvme_identify_nvmset_list.2 @@ -0,0 +1,25 @@ +.TH "nvme_identify_nvmset_list" 9 "nvme_identify_nvmset_list" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_identify_nvmset_list \- Retrieves NVM Set List +.SH SYNOPSIS +.B "int" nvme_identify_nvmset_list +.BI "(int fd " "," +.BI "__u16 nvmsetid " "," +.BI "struct nvme_id_nvmset_list *nvmset " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nvmsetid" 12 +NVM Set Identifier +.IP "nvmset" 12 +User space destination address to transfer the data +.SH "DESCRIPTION" +Retrieves an NVM Set List, \fIstruct nvme_id_nvmset_list\fP. The data structure +is an ordered list by NVM Set Identifier, starting with the first NVM Set +Identifier supported by the NVM subsystem that is equal to or greater than +the NVM Set Identifier. + +See \fIstruct nvme_id_nvmset_list\fP for the defintion of the returned structure. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_identify_primary_ctrl.2 b/doc/man/nvme_identify_primary_ctrl.2 new file mode 100644 index 0000000..8654539 --- /dev/null +++ b/doc/man/nvme_identify_primary_ctrl.2 @@ -0,0 +1,20 @@ +.TH "nvme_identify_primary_ctrl" 9 "nvme_identify_primary_ctrl" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_identify_primary_ctrl \- Retrieve NVMe Primary Controller identification +.SH SYNOPSIS +.B "int" nvme_identify_primary_ctrl +.BI "(int fd " "," +.BI "__u16 cntid " "," +.BI "struct nvme_primary_ctrl_cap *cap " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "cntid" 12 +Return controllers starting at this identifier +.IP "cap" 12 +User space destination buffer address to transfer the data +.SH "DESCRIPTION" +See \fIstruct nvme_primary_ctrl_cap\fP for the defintion of the returned structure, \fIcap\fP. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_identify_secondary_ctrl_list.2 b/doc/man/nvme_identify_secondary_ctrl_list.2 new file mode 100644 index 0000000..7a81cce --- /dev/null +++ b/doc/man/nvme_identify_secondary_ctrl_list.2 @@ -0,0 +1,29 @@ +.TH "nvme_identify_secondary_ctrl_list" 9 "nvme_identify_secondary_ctrl_list" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_identify_secondary_ctrl_list \- Retrieves secondary controller list +.SH SYNOPSIS +.B "int" nvme_identify_secondary_ctrl_list +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "__u16 cntid " "," +.BI "struct nvme_secondary_ctrl_list *sc_list " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Namespace identifier +.IP "cntid" 12 +Return controllers starting at this identifier +.IP "sc_list" 12 +User space destination address to transfer the data +.SH "DESCRIPTION" +A Secondary Controller List is returned to the host for up to 127 secondary +controllers associated with the primary controller processing this command. +The list contains entries for controller identifiers greater than or equal +to the value specified in the Controller Identifier (cntid). + +See \fIstruct nvme_secondary_ctrls_list\fP for a defintion of the returned +structure. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_identify_uuid.2 b/doc/man/nvme_identify_uuid.2 new file mode 100644 index 0000000..dc19985 --- /dev/null +++ b/doc/man/nvme_identify_uuid.2 @@ -0,0 +1,20 @@ +.TH "nvme_identify_uuid" 9 "nvme_identify_uuid" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_identify_uuid \- Retrieves device's UUIDs +.SH SYNOPSIS +.B "int" nvme_identify_uuid +.BI "(int fd " "," +.BI "struct nvme_id_uuid_list *uuid_list " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "uuid_list" 12 +User space destination address to transfer the data +.SH "DESCRIPTION" +Each UUID List entry is either 0h, the NVMe Invalid UUID, or a valid UUID. +Valid UUIDs are those which are non-zero and are not the NVMe Invalid UUID. + +See \fIstruct nvme_id_uuid_list\fP for the definition of the returned structure. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_init_copy_range.2 b/doc/man/nvme_init_copy_range.2 new file mode 100644 index 0000000..b49dd53 --- /dev/null +++ b/doc/man/nvme_init_copy_range.2 @@ -0,0 +1,27 @@ +.TH "nvme_init_copy_range" 9 "nvme_init_copy_range" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_init_copy_range \- Constructs a copy range structure +.SH SYNOPSIS +.B "void" nvme_init_copy_range +.BI "(struct nvme_copy_range *copy " "," +.BI "__u16 *nlbs " "," +.BI "__u64 *slbas " "," +.BI "__u32 *eilbrts " "," +.BI "__u32 *elbatms " "," +.BI "__u32 *elbats " "," +.BI "__u16 nr " ");" +.SH ARGUMENTS +.IP "copy" 12 +Copy range array +.IP "nlbs" 12 +Number of logical blocks +.IP "slbas" 12 +Starting LBA +.IP "eilbrts" 12 +Expected initial logical block reference tag +.IP "elbatms" 12 +Expected logical block application tag mask +.IP "elbats" 12 +Expected logical block application tag +.IP "nr" 12 +Number of descriptors to construct diff --git a/doc/man/nvme_init_ctrl.2 b/doc/man/nvme_init_ctrl.2 new file mode 100644 index 0000000..1799484 --- /dev/null +++ b/doc/man/nvme_init_ctrl.2 @@ -0,0 +1,17 @@ +.TH "nvme_init_ctrl" 9 "nvme_init_ctrl" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_init_ctrl \- Initialize nvme_ctrl_t object for an existing controller. +.SH SYNOPSIS +.B "int" nvme_init_ctrl +.BI "(nvme_host_t h " "," +.BI "nvme_ctrl_t c " "," +.BI "int instance " ");" +.SH ARGUMENTS +.IP "h" 12 +nvme_host_t object +.IP "c" 12 +nvme_ctrl_t object +.IP "instance" 12 +Instance number (e.g. 1 for nvme1) +.SH "RETURN" +The \fBioctl\fP return code. Typically 0 on success. diff --git a/doc/man/nvme_init_ctrl_list.2 b/doc/man/nvme_init_ctrl_list.2 new file mode 100644 index 0000000..3173143 --- /dev/null +++ b/doc/man/nvme_init_ctrl_list.2 @@ -0,0 +1,18 @@ +.TH "nvme_init_ctrl_list" 9 "nvme_init_ctrl_list" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_init_ctrl_list \- Initialize an nvme_ctrl_list structure from an array. +.SH SYNOPSIS +.B "void" nvme_init_ctrl_list +.BI "(struct nvme_ctrl_list *cntlist " "," +.BI "__u16 num_ctrls " "," +.BI "__u16 *ctrlist " ");" +.SH ARGUMENTS +.IP "cntlist" 12 +The controller list structure to initialize +.IP "num_ctrls" 12 +The number of controllers in the array, \fIctrlist\fP. +.IP "ctrlist" 12 +An array of controller identifiers in CPU native endian. +.SH "DESCRIPTION" +This is intended to be used with any command that takes a controller list +argument. See \fBnvme_ns_attach_ctrls\fP and \fBnvme_ns_detach\fP. diff --git a/doc/man/nvme_init_dsm_range.2 b/doc/man/nvme_init_dsm_range.2 new file mode 100644 index 0000000..260169d --- /dev/null +++ b/doc/man/nvme_init_dsm_range.2 @@ -0,0 +1,27 @@ +.TH "nvme_init_dsm_range" 9 "nvme_init_dsm_range" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_init_dsm_range \- Constructs a data set range structure +.SH SYNOPSIS +.B "void" nvme_init_dsm_range +.BI "(struct nvme_dsm_range *dsm " "," +.BI "__u32 *ctx_attrs " "," +.BI "__u32 *llbas " "," +.BI "__u64 *slbas " "," +.BI "__u16 nr_ranges " ");" +.SH ARGUMENTS +.IP "dsm" 12 +DSM range array +.IP "ctx_attrs" 12 +Array of context attributes +.IP "llbas" 12 +Array of length in logical blocks +.IP "slbas" 12 +Array of starting logical blocks +.IP "nr_ranges" 12 +The size of the dsm arrays +.SH "DESCRIPTION" +Each array must be the same size of size 'nr_ranges'. This is intended to be +used with constructing a payload for \fBnvme_dsm\fP. +.SH "RETURN" +The nvme command status if a response was received or -errno +otherwise. diff --git a/doc/man/nvme_init_logging.2 b/doc/man/nvme_init_logging.2 new file mode 100644 index 0000000..d2c2829 --- /dev/null +++ b/doc/man/nvme_init_logging.2 @@ -0,0 +1,20 @@ +.TH "nvme_init_logging" 9 "nvme_init_logging" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_init_logging \- Initialize logging +.SH SYNOPSIS +.B "void" nvme_init_logging +.BI "(nvme_root_t r " "," +.BI "int lvl " "," +.BI "bool log_pid " "," +.BI "bool log_tstamp " ");" +.SH ARGUMENTS +.IP "r" 12 +nvme_root_t context +.IP "lvl" 12 +Logging level to set +.IP "log_pid" 12 +Boolean to enable logging of the PID +.IP "log_tstamp" 12 +Boolean to enable logging of the timestamp +.SH "DESCRIPTION" +Sets the default logging variables for the library. diff --git a/doc/man/nvme_io.2 b/doc/man/nvme_io.2 new file mode 100644 index 0000000..422b922 --- /dev/null +++ b/doc/man/nvme_io.2 @@ -0,0 +1,15 @@ +.TH "nvme_io" 9 "nvme_io" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_io \- Submit an nvme user I/O command +.SH SYNOPSIS +.B "int" nvme_io +.BI "(struct nvme_io_args *args " "," +.BI "__u8 opcode " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_io_args\fP argument structure +.IP "opcode" 12 +Opcode to execute +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_io_args.2 b/doc/man/nvme_io_args.2 new file mode 100644 index 0000000..4993da8 --- /dev/null +++ b/doc/man/nvme_io_args.2 @@ -0,0 +1,91 @@ +.TH "libnvme" 9 "struct nvme_io_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_io_args \- Arguments for NVMe I/O commands +.SH SYNOPSIS +struct nvme_io_args { +.br +.BI " __u64 slba;" +.br +.BI " __u64 storage_tag;" +.br +.BI " __u32 *result;" +.br +.BI " void *data;" +.br +.BI " void *metadata;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u32 nsid;" +.br +.BI " __u32 reftag;" +.br +.BI " __u32 data_len;" +.br +.BI " __u32 metadata_len;" +.br +.BI " __u16 nlb;" +.br +.BI " __u16 control;" +.br +.BI " __u16 apptag;" +.br +.BI " __u16 appmask;" +.br +.BI " __u16 dspec;" +.br +.BI " __u8 dsm;" +.br +.BI " +}; +.br + +.SH Members +.IP "slba" 12 +Starting logical block +.IP "storage_tag" 12 +This filed specifies Variable Sized Expected Logical Block +Storage Tag (ELBST) and Expected Logical Block Reference +Tag (ELBRT) +.IP "result" 12 +The command completion result from CQE dword0 +.IP "data" 12 +Pointer to user address of the data buffer +.IP "metadata" 12 +Pointer to user address of the metadata buffer +.IP "args_size" 12 +Size of \fIstruct nvme_io_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "nsid" 12 +Namespace ID +.IP "reftag" 12 +This field specifies the Initial Logical Block Reference Tag +expected value. Used only if the namespace is formatted to use +end-to-end protection information. +.IP "data_len" 12 +Length of user buffer, \fIdata\fP, in bytes +.IP "metadata_len" 12 +Length of user buffer, \fImetadata\fP, in bytes +.IP "nlb" 12 +Number of logical blocks to send (0's based value) +.IP "control" 12 +Command control flags, see \fIenum nvme_io_control_flags\fP. +.IP "apptag" 12 +This field specifies the Application Tag Mask expected value. +Used only if the namespace is formatted to use end-to-end +protection information. +.IP "appmask" 12 +This field specifies the Application Tag expected value. Used +only if the namespace is formatted to use end-to-end protection +information. +.IP "dspec" 12 +Directive specific value +.IP "dsm" 12 +Data set management attributes, see \fIenum nvme_io_dsm_flags\fP diff --git a/doc/man/nvme_io_control_flags.2 b/doc/man/nvme_io_control_flags.2 new file mode 100644 index 0000000..43ee21f --- /dev/null +++ b/doc/man/nvme_io_control_flags.2 @@ -0,0 +1,60 @@ +.TH "libnvme" 9 "enum nvme_io_control_flags" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_io_control_flags \- +.SH SYNOPSIS +enum nvme_io_control_flags { +.br +.BI " NVME_IO_DTYPE_STREAMS" +, +.br +.br +.BI " NVME_IO_DEAC" +, +.br +.br +.BI " NVME_IO_ZNS_APPEND_PIREMAP" +, +.br +.br +.BI " NVME_IO_PRINFO_PRCHK_REF" +, +.br +.br +.BI " NVME_IO_PRINFO_PRCHK_APP" +, +.br +.br +.BI " NVME_IO_PRINFO_PRCHK_GUARD" +, +.br +.br +.BI " NVME_IO_PRINFO_PRACT" +, +.br +.br +.BI " NVME_IO_FUA" +, +.br +.br +.BI " NVME_IO_LR" + +}; +.SH Constants +.IP "NVME_IO_DTYPE_STREAMS" 12 +Directive Type Streams +.IP "NVME_IO_DEAC" 12 +Deallocate +.IP "NVME_IO_ZNS_APPEND_PIREMAP" 12 +Protection Information Remap +.IP "NVME_IO_PRINFO_PRCHK_REF" 12 +Protection Information Check Reference Tag +.IP "NVME_IO_PRINFO_PRCHK_APP" 12 +Protection Information Check Application Tag +.IP "NVME_IO_PRINFO_PRCHK_GUARD" 12 +Protection Information Check Guard field +.IP "NVME_IO_PRINFO_PRACT" 12 +Protection Information Action +.IP "NVME_IO_FUA" 12 +Force Unit Access +.IP "NVME_IO_LR" 12 +Limited Retry diff --git a/doc/man/nvme_io_dsm_flags.2 b/doc/man/nvme_io_dsm_flags.2 new file mode 100644 index 0000000..5daacc3 --- /dev/null +++ b/doc/man/nvme_io_dsm_flags.2 @@ -0,0 +1,96 @@ +.TH "libnvme" 9 "enum nvme_io_dsm_flags" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_io_dsm_flags \- +.SH SYNOPSIS +enum nvme_io_dsm_flags { +.br +.BI " NVME_IO_DSM_FREQ_UNSPEC" +, +.br +.br +.BI " NVME_IO_DSM_FREQ_TYPICAL" +, +.br +.br +.BI " NVME_IO_DSM_FREQ_RARE" +, +.br +.br +.BI " NVME_IO_DSM_FREQ_READS" +, +.br +.br +.BI " NVME_IO_DSM_FREQ_WRITES" +, +.br +.br +.BI " NVME_IO_DSM_FREQ_RW" +, +.br +.br +.BI " NVME_IO_DSM_FREQ_ONCE" +, +.br +.br +.BI " NVME_IO_DSM_FREQ_PREFETCH" +, +.br +.br +.BI " NVME_IO_DSM_FREQ_TEMP" +, +.br +.br +.BI " NVME_IO_DSM_LATENCY_NONE" +, +.br +.br +.BI " NVME_IO_DSM_LATENCY_IDLE" +, +.br +.br +.BI " NVME_IO_DSM_LATENCY_NORM" +, +.br +.br +.BI " NVME_IO_DSM_LATENCY_LOW" +, +.br +.br +.BI " NVME_IO_DSM_SEQ_REQ" +, +.br +.br +.BI " NVME_IO_DSM_COMPRESSED" + +}; +.SH Constants +.IP "NVME_IO_DSM_FREQ_UNSPEC" 12 +No frequency information provided +.IP "NVME_IO_DSM_FREQ_TYPICAL" 12 +Typical number of reads and writes +expected for this LBA range +.IP "NVME_IO_DSM_FREQ_RARE" 12 +Infrequent writes and infrequent +reads to the LBA range indicated +.IP "NVME_IO_DSM_FREQ_READS" 12 +Infrequent writes and frequent +reads to the LBA range indicated +.IP "NVME_IO_DSM_FREQ_WRITES" 12 +Frequent writes and infrequent +reads to the LBA range indicated +.IP "NVME_IO_DSM_FREQ_RW" 12 +Frequent writes and frequent reads +to the LBA range indicated +.IP "NVME_IO_DSM_FREQ_ONCE" 12 +.IP "NVME_IO_DSM_FREQ_PREFETCH" 12 +.IP "NVME_IO_DSM_FREQ_TEMP" 12 +.IP "NVME_IO_DSM_LATENCY_NONE" 12 +No latency information provided +.IP "NVME_IO_DSM_LATENCY_IDLE" 12 +Longer latency acceptable +.IP "NVME_IO_DSM_LATENCY_NORM" 12 +Typical latency +.IP "NVME_IO_DSM_LATENCY_LOW" 12 +Smallest possible latency +.IP "NVME_IO_DSM_SEQ_REQ" 12 +.IP "NVME_IO_DSM_COMPRESSED" 12 diff --git a/doc/man/nvme_io_opcode.2 b/doc/man/nvme_io_opcode.2 new file mode 100644 index 0000000..74fd864 --- /dev/null +++ b/doc/man/nvme_io_opcode.2 @@ -0,0 +1,102 @@ +.TH "libnvme" 9 "enum nvme_io_opcode" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_io_opcode \- +.SH SYNOPSIS +enum nvme_io_opcode { +.br +.BI " nvme_cmd_flush" +, +.br +.br +.BI " nvme_cmd_write" +, +.br +.br +.BI " nvme_cmd_read" +, +.br +.br +.BI " nvme_cmd_write_uncor" +, +.br +.br +.BI " nvme_cmd_compare" +, +.br +.br +.BI " nvme_cmd_write_zeroes" +, +.br +.br +.BI " nvme_cmd_dsm" +, +.br +.br +.BI " nvme_cmd_verify" +, +.br +.br +.BI " nvme_cmd_resv_register" +, +.br +.br +.BI " nvme_cmd_resv_report" +, +.br +.br +.BI " nvme_cmd_resv_acquire" +, +.br +.br +.BI " nvme_cmd_resv_release" +, +.br +.br +.BI " nvme_cmd_copy" +, +.br +.br +.BI " nvme_zns_cmd_mgmt_send" +, +.br +.br +.BI " nvme_zns_cmd_mgmt_recv" +, +.br +.br +.BI " nvme_zns_cmd_append" + +}; +.SH Constants +.IP "nvme_cmd_flush" 12 +Flush +.IP "nvme_cmd_write" 12 +Write +.IP "nvme_cmd_read" 12 +Read +.IP "nvme_cmd_write_uncor" 12 +Write Uncorrectable +.IP "nvme_cmd_compare" 12 +Compare +.IP "nvme_cmd_write_zeroes" 12 +write Zeros +.IP "nvme_cmd_dsm" 12 +Dataset Management +.IP "nvme_cmd_verify" 12 +Verify +.IP "nvme_cmd_resv_register" 12 +Reservation Register +.IP "nvme_cmd_resv_report" 12 +Reservation Report +.IP "nvme_cmd_resv_acquire" 12 +Reservation Acquire +.IP "nvme_cmd_resv_release" 12 +Reservation Release +.IP "nvme_cmd_copy" 12 +Copy +.IP "nvme_zns_cmd_mgmt_send" 12 +Zone Management Send +.IP "nvme_zns_cmd_mgmt_recv" 12 +Zone Management Receive +.IP "nvme_zns_cmd_append" 12 +Zone Append diff --git a/doc/man/nvme_io_passthru.2 b/doc/man/nvme_io_passthru.2 new file mode 100644 index 0000000..0e848ea --- /dev/null +++ b/doc/man/nvme_io_passthru.2 @@ -0,0 +1,71 @@ +.TH "nvme_io_passthru" 9 "nvme_io_passthru" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_io_passthru \- Submit an nvme io passthrough command +.SH SYNOPSIS +.B "int" nvme_io_passthru +.BI "(int fd " "," +.BI "__u8 opcode " "," +.BI "__u8 flags " "," +.BI "__u16 rsvd " "," +.BI "__u32 nsid " "," +.BI "__u32 cdw2 " "," +.BI "__u32 cdw3 " "," +.BI "__u32 cdw10 " "," +.BI "__u32 cdw11 " "," +.BI "__u32 cdw12 " "," +.BI "__u32 cdw13 " "," +.BI "__u32 cdw14 " "," +.BI "__u32 cdw15 " "," +.BI "__u32 data_len " "," +.BI "void *data " "," +.BI "__u32 metadata_len " "," +.BI "void *metadata " "," +.BI "__u32 timeout_ms " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "opcode" 12 +The nvme io command to send +.IP "flags" 12 +NVMe command flags (not used) +.IP "rsvd" 12 +Reserevd for future use +.IP "nsid" 12 +Namespace identifier +.IP "cdw2" 12 +Command dword 2 +.IP "cdw3" 12 +Command dword 3 +.IP "cdw10" 12 +Command dword 10 +.IP "cdw11" 12 +Command dword 11 +.IP "cdw12" 12 +Command dword 12 +.IP "cdw13" 12 +Command dword 13 +.IP "cdw14" 12 +Command dword 14 +.IP "cdw15" 12 +Command dword 15 +.IP "data_len" 12 +Length of the data transfered in this command in bytes +.IP "data" 12 +Pointer to user address of the data buffer +.IP "metadata_len" 12 +Length of metadata transfered in this command +.IP "metadata" 12 +Pointer to user address of the metadata buffer +.IP "timeout_ms" 12 +How long the kernel waits for the command to complete +.IP "result" 12 +Optional field to return the result from the CQE dword 0 +.SH "DESCRIPTION" +Parameterized form of \fBnvme_submit_io_passthru\fP. This sets up and submits +a \fIstruct nvme_passthru_cmd\fP. + +Known values for \fIopcode\fP are defined in \fIenum nvme_io_opcode\fP. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_lba_range_type.2 b/doc/man/nvme_lba_range_type.2 new file mode 100644 index 0000000..14caf22 --- /dev/null +++ b/doc/man/nvme_lba_range_type.2 @@ -0,0 +1,15 @@ +.TH "libnvme" 9 "struct nvme_lba_range_type" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_lba_range_type \- +.SH SYNOPSIS +struct nvme_lba_range_type { +.br +.BI " struct nvme_lba_range_type_entry entry[NVME_FEAT_LBA_RANGE_MAX];" +.br +.BI " +}; +.br + +.SH Members +.IP "entry" 12 +LBA range type entry diff --git a/doc/man/nvme_lba_range_type_entry.2 b/doc/man/nvme_lba_range_type_entry.2 new file mode 100644 index 0000000..ef9496b --- /dev/null +++ b/doc/man/nvme_lba_range_type_entry.2 @@ -0,0 +1,39 @@ +.TH "libnvme" 9 "struct nvme_lba_range_type_entry" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_lba_range_type_entry \- +.SH SYNOPSIS +struct nvme_lba_range_type_entry { +.br +.BI " __u8 type;" +.br +.BI " __u8 attributes;" +.br +.BI " __u8 rsvd2[14];" +.br +.BI " __u64 slba;" +.br +.BI " __u64 nlb;" +.br +.BI " __u8 guid[16];" +.br +.BI " __u8 rsvd48[16];" +.br +.BI " +}; +.br + +.SH Members +.IP "type" 12 +Specifies the Type of the LBA range +.IP "attributes" 12 +Specifies attributes of the LBA range +.IP "rsvd2" 12 +Reserved +.IP "slba" 12 +Starting LBA +.IP "nlb" 12 +Number of Logical Blocks +.IP "guid" 12 +Unique Identifier +.IP "rsvd48" 12 +Reserved diff --git a/doc/man/nvme_lba_rd.2 b/doc/man/nvme_lba_rd.2 new file mode 100644 index 0000000..5203f90 --- /dev/null +++ b/doc/man/nvme_lba_rd.2 @@ -0,0 +1,23 @@ +.TH "libnvme" 9 "struct nvme_lba_rd" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_lba_rd \- +.SH SYNOPSIS +struct nvme_lba_rd { +.br +.BI " __le64 rslba;" +.br +.BI " __le32 rnlb;" +.br +.BI " __u8 rsvd12[4];" +.br +.BI " +}; +.br + +.SH Members +.IP "rslba" 12 +Range Starting LBA +.IP "rnlb" 12 +Range Number of Logical Blocks +.IP "rsvd12" 12 +Reserved diff --git a/doc/man/nvme_lba_status.2 b/doc/man/nvme_lba_status.2 new file mode 100644 index 0000000..c4b55f5 --- /dev/null +++ b/doc/man/nvme_lba_status.2 @@ -0,0 +1,27 @@ +.TH "libnvme" 9 "struct nvme_lba_status" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_lba_status \- +.SH SYNOPSIS +struct nvme_lba_status { +.br +.BI " __le32 nlsd;" +.br +.BI " __u8 cmpc;" +.br +.BI " __u8 rsvd5[3];" +.br +.BI " struct nvme_lba_status_desc descs[];" +.br +.BI " +}; +.br + +.SH Members +.IP "nlsd" 12 +Number of LBA Status Descriptors +.IP "cmpc" 12 +Completion Condition +.IP "rsvd5" 12 +Reserved +.IP "descs" 12 +LBA status descriptor Entry diff --git a/doc/man/nvme_lba_status_atype.2 b/doc/man/nvme_lba_status_atype.2 new file mode 100644 index 0000000..4cc9aa6 --- /dev/null +++ b/doc/man/nvme_lba_status_atype.2 @@ -0,0 +1,16 @@ +.TH "libnvme" 9 "enum nvme_lba_status_atype" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_lba_status_atype \- +.SH SYNOPSIS +enum nvme_lba_status_atype { +.br +.BI " NVME_LBA_STATUS_ATYPE_SCAN_UNTRACKED" +, +.br +.br +.BI " NVME_LBA_STATUS_ATYPE_SCAN_TRACKED" + +}; +.SH Constants +.IP "NVME_LBA_STATUS_ATYPE_SCAN_UNTRACKED" 12 +.IP "NVME_LBA_STATUS_ATYPE_SCAN_TRACKED" 12 diff --git a/doc/man/nvme_lba_status_desc.2 b/doc/man/nvme_lba_status_desc.2 new file mode 100644 index 0000000..c1d8309 --- /dev/null +++ b/doc/man/nvme_lba_status_desc.2 @@ -0,0 +1,31 @@ +.TH "libnvme" 9 "struct nvme_lba_status_desc" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_lba_status_desc \- +.SH SYNOPSIS +struct nvme_lba_status_desc { +.br +.BI " __le64 dslba;" +.br +.BI " __le32 nlb;" +.br +.BI " __u8 rsvd12;" +.br +.BI " __u8 status;" +.br +.BI " __u8 rsvd14[2];" +.br +.BI " +}; +.br + +.SH Members +.IP "dslba" 12 +Descriptor Starting LBA +.IP "nlb" 12 +Number of Logical Blocks +.IP "rsvd12" 12 +Reserved +.IP "status" 12 +Additional status about this LBA range +.IP "rsvd14" 12 +Reserved diff --git a/doc/man/nvme_lba_status_log.2 b/doc/man/nvme_lba_status_log.2 new file mode 100644 index 0000000..6574def --- /dev/null +++ b/doc/man/nvme_lba_status_log.2 @@ -0,0 +1,35 @@ +.TH "libnvme" 9 "struct nvme_lba_status_log" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_lba_status_log \- +.SH SYNOPSIS +struct nvme_lba_status_log { +.br +.BI " __le32 lslplen;" +.br +.BI " __le32 nlslne;" +.br +.BI " __le32 estulb;" +.br +.BI " __u8 rsvd12[2];" +.br +.BI " __le16 lsgc;" +.br +.BI " struct nvme_lbas_ns_element elements[];" +.br +.BI " +}; +.br + +.SH Members +.IP "lslplen" 12 +LBA Status Log Page Length +.IP "nlslne" 12 +Number of LBA Status Log Namespace Elements +.IP "estulb" 12 +Estimate of Unrecoverable Logical Blocks +.IP "rsvd12" 12 +Reserved +.IP "lsgc" 12 +LBA Status Generation Counter +.IP "elements" 12 +LBA Status Log Namespace Element List diff --git a/doc/man/nvme_lbaf.2 b/doc/man/nvme_lbaf.2 new file mode 100644 index 0000000..2270b8b --- /dev/null +++ b/doc/man/nvme_lbaf.2 @@ -0,0 +1,25 @@ +.TH "libnvme" 9 "struct nvme_lbaf" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_lbaf \- LBA Format Data Structure +.SH SYNOPSIS +struct nvme_lbaf { +.br +.BI " __le16 ms;" +.br +.BI " __u8 ds;" +.br +.BI " __u8 rp;" +.br +.BI " +}; +.br + +.SH Members +.IP "ms" 12 +Metadata Size indicates the number of metadata bytes provided per LBA +based on the LBA Data Size indicated. +.IP "ds" 12 +LBA Data Size indicates the LBA data size supported, reported as a +power of two. +.IP "rp" 12 +Relative Performance, see \fIenum nvme_lbaf_rp\fP. diff --git a/doc/man/nvme_lbaf_rp.2 b/doc/man/nvme_lbaf_rp.2 new file mode 100644 index 0000000..37d9ab6 --- /dev/null +++ b/doc/man/nvme_lbaf_rp.2 @@ -0,0 +1,37 @@ +.TH "libnvme" 9 "enum nvme_lbaf_rp" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_lbaf_rp \- This field indicates the relative performance of the LBA format indicated relative to other LBA formats supported by the controller. +.SH SYNOPSIS +enum nvme_lbaf_rp { +.br +.BI " NVME_LBAF_RP_BEST" +, +.br +.br +.BI " NVME_LBAF_RP_BETTER" +, +.br +.br +.BI " NVME_LBAF_RP_GOOD" +, +.br +.br +.BI " NVME_LBAF_RP_DEGRADED" +, +.br +.br +.BI " NVME_LBAF_RP_MASK" + +}; +.SH Constants +.IP "NVME_LBAF_RP_BEST" 12 +Best performance +.IP "NVME_LBAF_RP_BETTER" 12 +Better performance +.IP "NVME_LBAF_RP_GOOD" 12 +Good performance +.IP "NVME_LBAF_RP_DEGRADED" 12 +Degraded performance +.IP "NVME_LBAF_RP_MASK" 12 +Mask to get the relative performance value from the +field diff --git a/doc/man/nvme_lbart.2 b/doc/man/nvme_lbart.2 new file mode 100644 index 0000000..6c1ee8a --- /dev/null +++ b/doc/man/nvme_lbart.2 @@ -0,0 +1,48 @@ +.TH "libnvme" 9 "enum nvme_lbart" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_lbart \- +.SH SYNOPSIS +enum nvme_lbart { +.br +.BI " NVME_LBART_TYPE_GP" +, +.br +.br +.BI " NVME_LBART_TYPE_FS" +, +.br +.br +.BI " NVME_LBART_TYPE_RAID" +, +.br +.br +.BI " NVME_LBART_TYPE_CACHE" +, +.br +.br +.BI " NVME_LBART_TYPE_SWAP" +, +.br +.br +.BI " NVME_LBART_ATTRIB_TEMP" +, +.br +.br +.BI " NVME_LBART_ATTRIB_HIDE" + +}; +.SH Constants +.IP "NVME_LBART_TYPE_GP" 12 +General Purpose +.IP "NVME_LBART_TYPE_FS" 12 +Filesystem +.IP "NVME_LBART_TYPE_RAID" 12 +RAID +.IP "NVME_LBART_TYPE_CACHE" 12 +Cache +.IP "NVME_LBART_TYPE_SWAP" 12 +Page / swap file +.IP "NVME_LBART_ATTRIB_TEMP" 12 +Temp +.IP "NVME_LBART_ATTRIB_HIDE" 12 +Hidden diff --git a/doc/man/nvme_lbas_ns_element.2 b/doc/man/nvme_lbas_ns_element.2 new file mode 100644 index 0000000..5367ae1 --- /dev/null +++ b/doc/man/nvme_lbas_ns_element.2 @@ -0,0 +1,31 @@ +.TH "libnvme" 9 "struct nvme_lbas_ns_element" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_lbas_ns_element \- +.SH SYNOPSIS +struct nvme_lbas_ns_element { +.br +.BI " __le32 neid;" +.br +.BI " __le32 nlrd;" +.br +.BI " __u8 ratype;" +.br +.BI " __u8 rsvd8[7];" +.br +.BI " struct nvme_lba_rd lba_rd[];" +.br +.BI " +}; +.br + +.SH Members +.IP "neid" 12 +Namespace Element Identifier +.IP "nlrd" 12 +Number of LBA Range Descriptors +.IP "ratype" 12 +Recommended Action Type +.IP "rsvd8" 12 +Reserved +.IP "lba_rd" 12 +LBA Range Descriptor diff --git a/doc/man/nvme_lockdown.2 b/doc/man/nvme_lockdown.2 new file mode 100644 index 0000000..dd67871 --- /dev/null +++ b/doc/man/nvme_lockdown.2 @@ -0,0 +1,12 @@ +.TH "nvme_lockdown" 9 "nvme_lockdown" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_lockdown \- Issue lockdown command +.SH SYNOPSIS +.B "int" nvme_lockdown +.BI "(struct nvme_lockdown_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_lockdown_args\fP argument structure +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_lockdown_args.2 b/doc/man/nvme_lockdown_args.2 new file mode 100644 index 0000000..c8f83b5 --- /dev/null +++ b/doc/man/nvme_lockdown_args.2 @@ -0,0 +1,47 @@ +.TH "libnvme" 9 "struct nvme_lockdown_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_lockdown_args \- Arguments for the NVME Lockdown command +.SH SYNOPSIS +struct nvme_lockdown_args { +.br +.BI " __u32 *result;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u8 scp;" +.br +.BI " __u8 prhbt;" +.br +.BI " __u8 ifc;" +.br +.BI " __u8 ofi;" +.br +.BI " __u8 uuidx;" +.br +.BI " +}; +.br + +.SH Members +.IP "result" 12 +The command completion result from CQE dword0 +.IP "args_size" 12 +Size of \fIstruct nvme_lockdown_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms (0 for default timeout) +.IP "scp" 12 +Scope of the command +.IP "prhbt" 12 +Prohibit or allow the command opcode or Set Features command +.IP "ifc" 12 +Affected interface +.IP "ofi" 12 +Opcode or Feature Identifier +.IP "uuidx" 12 +UUID Index if controller supports this id selection method diff --git a/doc/man/nvme_log_ana_lsp.2 b/doc/man/nvme_log_ana_lsp.2 new file mode 100644 index 0000000..fc8f063 --- /dev/null +++ b/doc/man/nvme_log_ana_lsp.2 @@ -0,0 +1,16 @@ +.TH "libnvme" 9 "enum nvme_log_ana_lsp" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_log_ana_lsp \- +.SH SYNOPSIS +enum nvme_log_ana_lsp { +.br +.BI " NVME_LOG_ANA_LSP_RGO_NAMESPACES" +, +.br +.br +.BI " NVME_LOG_ANA_LSP_RGO_GROUPS_ONLY" + +}; +.SH Constants +.IP "NVME_LOG_ANA_LSP_RGO_NAMESPACES" 12 +.IP "NVME_LOG_ANA_LSP_RGO_GROUPS_ONLY" 12 diff --git a/doc/man/nvme_lookup_ctrl.2 b/doc/man/nvme_lookup_ctrl.2 new file mode 100644 index 0000000..6b42f4a --- /dev/null +++ b/doc/man/nvme_lookup_ctrl.2 @@ -0,0 +1,35 @@ +.TH "nvme_lookup_ctrl" 9 "nvme_lookup_ctrl" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_lookup_ctrl \- Lookup nvme_ctrl_t object +.SH SYNOPSIS +.B "nvme_ctrl_t" nvme_lookup_ctrl +.BI "(nvme_subsystem_t s " "," +.BI "const char *transport " "," +.BI "const char *traddr " "," +.BI "const char *host_traddr " "," +.BI "const char *host_iface " "," +.BI "const char *trsvcid " "," +.BI "nvme_ctrl_t p " ");" +.SH ARGUMENTS +.IP "s" 12 +\fInvme_subsystem_t\fP object +.IP "transport" 12 +Transport name +.IP "traddr" 12 +Transport address +.IP "host_traddr" 12 +Host transport address +.IP "host_iface" 12 +Host interface name +.IP "trsvcid" 12 +Transport service identifier +.IP "p" 12 +Previous controller instance +.SH "DESCRIPTION" +Lookup a controller in \fIs\fP based on \fItransport\fP, \fItraddr\fP, +\fIhost_traddr\fP, \fIhost_iface\fP, and \fItrsvcid\fP. \fItransport\fP must be specified, +other fields may be required depending on the transport. A new +object is created if none is found. If \fIp\fP is specified the lookup +will start at \fIp\fP instead of the first controller. +.SH "RETURN" +Controller instance diff --git a/doc/man/nvme_lookup_host.2 b/doc/man/nvme_lookup_host.2 new file mode 100644 index 0000000..f5fb23c --- /dev/null +++ b/doc/man/nvme_lookup_host.2 @@ -0,0 +1,20 @@ +.TH "nvme_lookup_host" 9 "nvme_lookup_host" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_lookup_host \- Lookup nvme_host_t object +.SH SYNOPSIS +.B "nvme_host_t" nvme_lookup_host +.BI "(nvme_root_t r " "," +.BI "const char *hostnqn " "," +.BI "const char *hostid " ");" +.SH ARGUMENTS +.IP "r" 12 +\fInvme_root_t\fP object +.IP "hostnqn" 12 +Host NQN +.IP "hostid" 12 +Host ID +.SH "DESCRIPTION" +Lookup a nvme_host_t object based on \fIhostnqn\fP and \fIhostid\fP +or create one if not found. +.SH "RETURN" +\fInvme_host_t\fP object diff --git a/doc/man/nvme_lookup_subsystem.2 b/doc/man/nvme_lookup_subsystem.2 new file mode 100644 index 0000000..5127f68 --- /dev/null +++ b/doc/man/nvme_lookup_subsystem.2 @@ -0,0 +1,20 @@ +.TH "nvme_lookup_subsystem" 9 "nvme_lookup_subsystem" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_lookup_subsystem \- Lookup nvme_subsystem_t object +.SH SYNOPSIS +.B "nvme_subsystem_t" nvme_lookup_subsystem +.BI "(struct nvme_host *h " "," +.BI "const char *name " "," +.BI "const char *subsysnqn " ");" +.SH ARGUMENTS +.IP "h" 12 +\fInvme_host_t\fP object +.IP "name" 12 +Name of the subsystem (may be NULL) +.IP "subsysnqn" 12 +Subsystem NQN +.SH "DESCRIPTION" +Lookup a \fInvme_subsystem_t\fP object in \fIh\fP base on \fIname\fP (if present) +and \fIsubsystemnqn\fP or create one if not found. +.SH "RETURN" +nvme_subsystme_t object diff --git a/doc/man/nvme_media_unit_config_desc.2 b/doc/man/nvme_media_unit_config_desc.2 new file mode 100644 index 0000000..e739f1d --- /dev/null +++ b/doc/man/nvme_media_unit_config_desc.2 @@ -0,0 +1,24 @@ +.TH "libnvme" 9 "struct nvme_media_unit_config_desc" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_media_unit_config_desc \- +.SH SYNOPSIS +struct nvme_media_unit_config_desc { +.br +.BI " __le16 muid;" +.br +.BI " __u8 rsvd2[4];" +.br +.BI " __le16 mudl;" +.br +.BI " +}; +.br + +.SH Members +.IP "muid" 12 +Media Unit Identifier +.IP "mudl" 12 +Media Unit Descriptor Length +.SH "Description" +Media Unit Configuration Descriptor +Structure Definitions diff --git a/doc/man/nvme_media_unit_stat_desc.2 b/doc/man/nvme_media_unit_stat_desc.2 new file mode 100644 index 0000000..26282e3 --- /dev/null +++ b/doc/man/nvme_media_unit_stat_desc.2 @@ -0,0 +1,47 @@ +.TH "libnvme" 9 "struct nvme_media_unit_stat_desc" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_media_unit_stat_desc \- +.SH SYNOPSIS +struct nvme_media_unit_stat_desc { +.br +.BI " __le16 muid;" +.br +.BI " __le16 domainid;" +.br +.BI " __le16 endgid;" +.br +.BI " __le16 nvmsetid;" +.br +.BI " __le16 cap_adj_fctr;" +.br +.BI " __u8 avl_spare;" +.br +.BI " __u8 percent_used;" +.br +.BI " __u8 mucs;" +.br +.BI " __u8 cio;" +.br +.BI " +}; +.br + +.SH Members +.IP "muid" 12 +Media Unit Identifier +.IP "domainid" 12 +Domain Identifier +.IP "endgid" 12 +Endurance Group Identifier +.IP "nvmsetid" 12 +NVM Set Identifier +.IP "cap_adj_fctr" 12 +Capacity Adjustment Factor +.IP "avl_spare" 12 +Available Spare +.IP "percent_used" 12 +Percentage Used +.IP "mucs" 12 +Number of Channels attached to media units +.IP "cio" 12 +Channel Identifiers Offset diff --git a/doc/man/nvme_media_unit_stat_log.2 b/doc/man/nvme_media_unit_stat_log.2 new file mode 100644 index 0000000..45affc3 --- /dev/null +++ b/doc/man/nvme_media_unit_stat_log.2 @@ -0,0 +1,31 @@ +.TH "libnvme" 9 "struct nvme_media_unit_stat_log" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_media_unit_stat_log \- +.SH SYNOPSIS +struct nvme_media_unit_stat_log { +.br +.BI " __le16 nmu;" +.br +.BI " __le16 cchans;" +.br +.BI " __le16 sel_config;" +.br +.BI " __u8 rsvd6[10];" +.br +.BI " struct nvme_media_unit_stat_desc mus_desc[];" +.br +.BI " +}; +.br + +.SH Members +.IP "nmu" 12 +Number unit status descriptor +.IP "cchans" 12 +Number of Channels +.IP "sel_config" 12 +Selected Configuration +.IP "rsvd6" 12 +Reserved +.IP "mus_desc" 12 +Media unit statistic descriptors diff --git a/doc/man/nvme_metadata_element_desc.2 b/doc/man/nvme_metadata_element_desc.2 new file mode 100644 index 0000000..32565a8 --- /dev/null +++ b/doc/man/nvme_metadata_element_desc.2 @@ -0,0 +1,27 @@ +.TH "libnvme" 9 "struct nvme_metadata_element_desc" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_metadata_element_desc \- Metadata Element Descriptor +.SH SYNOPSIS +struct nvme_metadata_element_desc { +.br +.BI " __u8 type;" +.br +.BI " __u8 rev;" +.br +.BI " __u16 len;" +.br +.BI " __u8 val[0];" +.br +.BI " +}; +.br + +.SH Members +.IP "type" 12 +Element Type (ET) +.IP "rev" 12 +Element Revision (ER) +.IP "len" 12 +Element Length (ELEN) +.IP "val" 12 +Element Value (EVAL), UTF-8 string diff --git a/doc/man/nvme_mi_cmd_supported_effects.2 b/doc/man/nvme_mi_cmd_supported_effects.2 new file mode 100644 index 0000000..14a723d --- /dev/null +++ b/doc/man/nvme_mi_cmd_supported_effects.2 @@ -0,0 +1,86 @@ +.TH "libnvme" 9 "enum nvme_mi_cmd_supported_effects" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_mi_cmd_supported_effects \- bit field definitions +.SH SYNOPSIS +enum nvme_mi_cmd_supported_effects { +.br +.BI " NVME_MI_CMD_SUPPORTED_EFFECTS_CSUPP" +, +.br +.br +.BI " NVME_MI_CMD_SUPPORTED_EFFECTS_UDCC" +, +.br +.br +.BI " NVME_MI_CMD_SUPPORTED_EFFECTS_NCC" +, +.br +.br +.BI " NVME_MI_CMD_SUPPORTED_EFFECTS_NIC" +, +.br +.br +.BI " NVME_MI_CMD_SUPPORTED_EFFECTS_CCC" +, +.br +.br +.BI " NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_SHIFT" +, +.br +.br +.BI " NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_MASK" +, +.br +.br +.BI " NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_NS" +, +.br +.br +.BI " NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_CTRL" +, +.br +.br +.BI " NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_NVM_SET" +, +.br +.br +.BI " NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_ENDGRP" +, +.br +.br +.BI " NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_DOMAIN" +, +.br +.br +.BI " NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_NSS" + +}; +.SH Constants +.IP "NVME_MI_CMD_SUPPORTED_EFFECTS_CSUPP" 12 +Command Supported +.IP "NVME_MI_CMD_SUPPORTED_EFFECTS_UDCC" 12 +User Data Conttent Change +.IP "NVME_MI_CMD_SUPPORTED_EFFECTS_NCC" 12 +Namespace Capability Change +.IP "NVME_MI_CMD_SUPPORTED_EFFECTS_NIC" 12 +Namespace Inventory Change +.IP "NVME_MI_CMD_SUPPORTED_EFFECTS_CCC" 12 +Controller Capability Change +.IP "NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_SHIFT" 12 +20 bit shift +.IP "NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_MASK" 12 +12 bit mask - 0xfff +.IP "NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_NS" 12 +Namespace Scope +.IP "NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_CTRL" 12 +Controller Scope +.IP "NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_NVM_SET" 12 +NVM Set Scope +.IP "NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_ENDGRP" 12 +Endurance Group Scope +.IP "NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_DOMAIN" 12 +Domain Scope +.IP "NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_NSS" 12 +NVM Subsystem Scope +.SH "Description" +MI Command Supported and Effects Data Structure definitions diff --git a/doc/man/nvme_mi_cmd_supported_effects_log.2 b/doc/man/nvme_mi_cmd_supported_effects_log.2 new file mode 100644 index 0000000..96763e7 --- /dev/null +++ b/doc/man/nvme_mi_cmd_supported_effects_log.2 @@ -0,0 +1,19 @@ +.TH "libnvme" 9 "struct nvme_mi_cmd_supported_effects_log" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_mi_cmd_supported_effects_log \- +.SH SYNOPSIS +struct nvme_mi_cmd_supported_effects_log { +.br +.BI " __le32 mi_cmd_support[NVME_LOG_MI_CMD_SUPPORTED_EFFECTS_MAX];" +.br +.BI " __le32 reserved1[NVME_LOG_MI_CMD_SUPPORTED_EFFECTS_RESERVED];" +.br +.BI " +}; +.br + +.SH Members +.IP "mi_cmd_support" 12 +NVMe-MI Commands Supported +.SH "Description" +NVMe-MI Commands Supported and Effects (Log Identifier 13h) diff --git a/doc/man/nvme_mi_css.2 b/doc/man/nvme_mi_css.2 new file mode 100644 index 0000000..f75db9e --- /dev/null +++ b/doc/man/nvme_mi_css.2 @@ -0,0 +1,78 @@ +.TH "libnvme" 9 "enum nvme_mi_css" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_mi_css \- +.SH SYNOPSIS +enum nvme_mi_css { +.br +.BI " NVME_MI_CCS_RDY" +, +.br +.br +.BI " NVME_MI_CSS_CFS" +, +.br +.br +.BI " NVME_MI_CSS_SHST" +, +.br +.br +.BI " NVME_MI_CSS_NSSRO" +, +.br +.br +.BI " NVME_MI_CSS_CECO" +, +.br +.br +.BI " NVME_MI_CSS_NAC" +, +.br +.br +.BI " NVME_MI_CSS_FA" +, +.br +.br +.BI " NVME_MI_CSS_CSTS" +, +.br +.br +.BI " NVME_MI_CSS_CTEMP" +, +.br +.br +.BI " NVME_MI_CSS_PDLU" +, +.br +.br +.BI " NVME_MI_CSS_SPARE" +, +.br +.br +.BI " NVME_MI_CSS_CCWARN" + +}; +.SH Constants +.IP "NVME_MI_CCS_RDY" 12 +Ready +.IP "NVME_MI_CSS_CFS" 12 +Controller Fatal Status +.IP "NVME_MI_CSS_SHST" 12 +Shutdown Status +.IP "NVME_MI_CSS_NSSRO" 12 +NVM Subsystem Reset Occurred +.IP "NVME_MI_CSS_CECO" 12 +Controller Enable Change Occurred +.IP "NVME_MI_CSS_NAC" 12 +Namespace Attribute Changed +.IP "NVME_MI_CSS_FA" 12 +Firmware Activated +.IP "NVME_MI_CSS_CSTS" 12 +Controller Status Change +.IP "NVME_MI_CSS_CTEMP" 12 +Composite Temperature Change +.IP "NVME_MI_CSS_PDLU" 12 +Percentage Used +.IP "NVME_MI_CSS_SPARE" 12 +Available Spare +.IP "NVME_MI_CSS_CCWARN" 12 +Critical Warning diff --git a/doc/man/nvme_mi_csts.2 b/doc/man/nvme_mi_csts.2 new file mode 100644 index 0000000..f9e388a --- /dev/null +++ b/doc/man/nvme_mi_csts.2 @@ -0,0 +1,48 @@ +.TH "libnvme" 9 "enum nvme_mi_csts" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_mi_csts \- +.SH SYNOPSIS +enum nvme_mi_csts { +.br +.BI " NVME_MI_CSTS_RDY" +, +.br +.br +.BI " NVME_MI_CSTS_CFS" +, +.br +.br +.BI " NVME_MI_CSTS_SHST" +, +.br +.br +.BI " NVME_MI_CSTS_NSSRO" +, +.br +.br +.BI " NVME_MI_CSTS_CECO" +, +.br +.br +.BI " NVME_MI_CSTS_NAC" +, +.br +.br +.BI " NVME_MI_CSTS_FA" + +}; +.SH Constants +.IP "NVME_MI_CSTS_RDY" 12 +Ready +.IP "NVME_MI_CSTS_CFS" 12 +Controller Fatal Status +.IP "NVME_MI_CSTS_SHST" 12 +Shutdown Status +.IP "NVME_MI_CSTS_NSSRO" 12 +NVM Subsystem Reset Occurred +.IP "NVME_MI_CSTS_CECO" 12 +Controller Enable Change Occurred +.IP "NVME_MI_CSTS_NAC" 12 +Namespace Attribute Changed +.IP "NVME_MI_CSTS_FA" 12 +Firmware Activated diff --git a/doc/man/nvme_mi_ctrl_health_status.2 b/doc/man/nvme_mi_ctrl_health_status.2 new file mode 100644 index 0000000..76cb616 --- /dev/null +++ b/doc/man/nvme_mi_ctrl_health_status.2 @@ -0,0 +1,39 @@ +.TH "libnvme" 9 "struct nvme_mi_ctrl_health_status" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_mi_ctrl_health_status \- +.SH SYNOPSIS +struct nvme_mi_ctrl_health_status { +.br +.BI " __le16 ctlid;" +.br +.BI " __le16 csts;" +.br +.BI " __le16 ctemp;" +.br +.BI " __u8 pdlu;" +.br +.BI " __u8 spare;" +.br +.BI " __u8 cwarn;" +.br +.BI " __u8 rsvd9[7];" +.br +.BI " +}; +.br + +.SH Members +.IP "ctlid" 12 +Controller Identifier +.IP "csts" 12 +Controller Status +.IP "ctemp" 12 +Composite Temperature +.IP "pdlu" 12 +Percentage Used +.IP "spare" 12 +Available Spare +.IP "cwarn" 12 +Critical Warning +.IP "rsvd9" 12 +Reserved diff --git a/doc/man/nvme_mi_cwarn.2 b/doc/man/nvme_mi_cwarn.2 new file mode 100644 index 0000000..11ccbc8 --- /dev/null +++ b/doc/man/nvme_mi_cwarn.2 @@ -0,0 +1,36 @@ +.TH "libnvme" 9 "enum nvme_mi_cwarn" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_mi_cwarn \- +.SH SYNOPSIS +enum nvme_mi_cwarn { +.br +.BI " NVME_MI_CWARN_ST" +, +.br +.br +.BI " NVME_MI_CWARN_TAUT" +, +.br +.br +.BI " NVME_MI_CWARN_RD" +, +.br +.br +.BI " NVME_MI_CWARN_RO" +, +.br +.br +.BI " NVME_MI_CWARN_VMBF" + +}; +.SH Constants +.IP "NVME_MI_CWARN_ST" 12 +Spare Threshold +.IP "NVME_MI_CWARN_TAUT" 12 +Temperature Above or Under Threshold +.IP "NVME_MI_CWARN_RD" 12 +Reliability Degraded +.IP "NVME_MI_CWARN_RO" 12 +Read Only +.IP "NVME_MI_CWARN_VMBF" 12 +Volatile Memory Backup Failed diff --git a/doc/man/nvme_mi_elem.2 b/doc/man/nvme_mi_elem.2 new file mode 100644 index 0000000..17be0ef --- /dev/null +++ b/doc/man/nvme_mi_elem.2 @@ -0,0 +1,48 @@ +.TH "libnvme" 9 "enum nvme_mi_elem" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_mi_elem \- +.SH SYNOPSIS +enum nvme_mi_elem { +.br +.BI " NVME_MI_ELEM_EED" +, +.br +.br +.BI " NVME_MI_ELEM_USCE" +, +.br +.br +.BI " NVME_MI_ELEM_ECED" +, +.br +.br +.BI " NVME_MI_ELEM_LED" +, +.br +.br +.BI " NVME_MI_ELEM_SMBMED" +, +.br +.br +.BI " NVME_MI_ELEM_PCIESED" +, +.br +.br +.BI " NVME_MI_ELEM_NVMED" + +}; +.SH Constants +.IP "NVME_MI_ELEM_EED" 12 +Extended Element Descriptor +.IP "NVME_MI_ELEM_USCE" 12 +Upstream Connector Element Descriptor +.IP "NVME_MI_ELEM_ECED" 12 +Expansion Connector Element Descriptor +.IP "NVME_MI_ELEM_LED" 12 +Label Element Descriptor +.IP "NVME_MI_ELEM_SMBMED" 12 +SMBus/I2C Mux Element Descriptor +.IP "NVME_MI_ELEM_PCIESED" 12 +PCIe Switch Element Descriptor +.IP "NVME_MI_ELEM_NVMED" 12 +NVM Subsystem Element Descriptor diff --git a/doc/man/nvme_mi_nvm_ss_health_status.2 b/doc/man/nvme_mi_nvm_ss_health_status.2 new file mode 100644 index 0000000..55c6d96 --- /dev/null +++ b/doc/man/nvme_mi_nvm_ss_health_status.2 @@ -0,0 +1,35 @@ +.TH "libnvme" 9 "struct nvme_mi_nvm_ss_health_status" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_mi_nvm_ss_health_status \- +.SH SYNOPSIS +struct nvme_mi_nvm_ss_health_status { +.br +.BI " __u8 nss;" +.br +.BI " __u8 sw;" +.br +.BI " __u8 ctemp;" +.br +.BI " __u8 pdlu;" +.br +.BI " __le16 ccs;" +.br +.BI " __u8 rsvd8[2];" +.br +.BI " +}; +.br + +.SH Members +.IP "nss" 12 +NVM Subsystem Status +.IP "sw" 12 +Smart Warnings +.IP "ctemp" 12 +Composite Temperature +.IP "pdlu" 12 +Percentage Drive Life Used +.IP "ccs" 12 +Composite Controller Status +.IP "rsvd8" 12 +Reserved diff --git a/doc/man/nvme_mi_osc.2 b/doc/man/nvme_mi_osc.2 new file mode 100644 index 0000000..df270a2 --- /dev/null +++ b/doc/man/nvme_mi_osc.2 @@ -0,0 +1,19 @@ +.TH "libnvme" 9 "struct nvme_mi_osc" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_mi_osc \- +.SH SYNOPSIS +struct nvme_mi_osc { +.br +.BI " __u8 type;" +.br +.BI " __u8 opc;" +.br +.BI " +}; +.br + +.SH Members +.IP "type" 12 +Command Type +.IP "opc" 12 +Opcode diff --git a/doc/man/nvme_mi_port_pcie.2 b/doc/man/nvme_mi_port_pcie.2 new file mode 100644 index 0000000..5221f02 --- /dev/null +++ b/doc/man/nvme_mi_port_pcie.2 @@ -0,0 +1,39 @@ +.TH "libnvme" 9 "struct nvme_mi_port_pcie" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_mi_port_pcie \- +.SH SYNOPSIS +struct nvme_mi_port_pcie { +.br +.BI " __u8 mps;" +.br +.BI " __u8 sls;" +.br +.BI " __u8 cls;" +.br +.BI " __u8 mlw;" +.br +.BI " __u8 nlw;" +.br +.BI " __u8 pn;" +.br +.BI " __u8 rsvd14[18];" +.br +.BI " +}; +.br + +.SH Members +.IP "mps" 12 +PCIe Maximum Payload Size +.IP "sls" 12 +PCIe Supported Link Speeds Vector +.IP "cls" 12 +PCIe Current Link Speed +.IP "mlw" 12 +PCIe Maximum Link Width +.IP "nlw" 12 +PCIe Negotiated Link Width +.IP "pn" 12 +PCIe Port Number +.IP "rsvd14" 12 +Reserved diff --git a/doc/man/nvme_mi_port_smb.2 b/doc/man/nvme_mi_port_smb.2 new file mode 100644 index 0000000..e7f3bfa --- /dev/null +++ b/doc/man/nvme_mi_port_smb.2 @@ -0,0 +1,35 @@ +.TH "libnvme" 9 "struct nvme_mi_port_smb" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_mi_port_smb \- +.SH SYNOPSIS +struct nvme_mi_port_smb { +.br +.BI " __u8 vpd_addr;" +.br +.BI " __u8 mvpd_freq;" +.br +.BI " __u8 mme_addr;" +.br +.BI " __u8 mme_freq;" +.br +.BI " __u8 nvmebm;" +.br +.BI " __u8 rsvd13[19];" +.br +.BI " +}; +.br + +.SH Members +.IP "vpd_addr" 12 +Current VPD SMBus/I2C Address +.IP "mvpd_freq" 12 +Maximum VPD Access SMBus/I2C Frequency +.IP "mme_addr" 12 +Current Management Endpoint SMBus/I2C Address +.IP "mme_freq" 12 +Maximum Management Endpoint SMBus/I2C Frequency +.IP "nvmebm" 12 +NVMe Basic Management +.IP "rsvd13" 12 +Reserved diff --git a/doc/man/nvme_mi_read_ctrl_info.2 b/doc/man/nvme_mi_read_ctrl_info.2 new file mode 100644 index 0000000..790b652 --- /dev/null +++ b/doc/man/nvme_mi_read_ctrl_info.2 @@ -0,0 +1,47 @@ +.TH "libnvme" 9 "struct nvme_mi_read_ctrl_info" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_mi_read_ctrl_info \- +.SH SYNOPSIS +struct nvme_mi_read_ctrl_info { +.br +.BI " __u8 portid;" +.br +.BI " __u8 rsvd1[4];" +.br +.BI " __u8 prii;" +.br +.BI " __le16 pri;" +.br +.BI " __le16 vid;" +.br +.BI " __le16 did;" +.br +.BI " __le16 ssvid;" +.br +.BI " __le16 ssid;" +.br +.BI " __u8 rsvd16[16];" +.br +.BI " +}; +.br + +.SH Members +.IP "portid" 12 +Port Identifier +.IP "rsvd1" 12 +Reserved +.IP "prii" 12 +PCIe Routing ID Information +.IP "pri" 12 +PCIe Routing ID +.IP "vid" 12 +PCI Vendor ID +.IP "did" 12 +PCI Device ID +.IP "ssvid" 12 +PCI Subsystem Vendor ID +.IP "ssid" 12 +PCI Subsystem Device ID +.IP "rsvd16" 12 +Reserved diff --git a/doc/man/nvme_mi_read_nvm_ss_info.2 b/doc/man/nvme_mi_read_nvm_ss_info.2 new file mode 100644 index 0000000..c063097 --- /dev/null +++ b/doc/man/nvme_mi_read_nvm_ss_info.2 @@ -0,0 +1,27 @@ +.TH "libnvme" 9 "struct nvme_mi_read_nvm_ss_info" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_mi_read_nvm_ss_info \- +.SH SYNOPSIS +struct nvme_mi_read_nvm_ss_info { +.br +.BI " __u8 nump;" +.br +.BI " __u8 mjr;" +.br +.BI " __u8 mnr;" +.br +.BI " __u8 rsvd3[29];" +.br +.BI " +}; +.br + +.SH Members +.IP "nump" 12 +Number of Ports +.IP "mjr" 12 +NVMe-MI Major Version Number +.IP "mnr" 12 +NVMe-MI Minor Version Number +.IP "rsvd3" 12 +Reserved diff --git a/doc/man/nvme_mi_read_port_info.2 b/doc/man/nvme_mi_read_port_info.2 new file mode 100644 index 0000000..dd634cb --- /dev/null +++ b/doc/man/nvme_mi_read_port_info.2 @@ -0,0 +1,41 @@ +.TH "libnvme" 9 "struct nvme_mi_read_port_info" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_mi_read_port_info \- +.SH SYNOPSIS +struct nvme_mi_read_port_info { +.br +.BI " __u8 portt;" +.br +.BI " __u8 rsvd1;" +.br +.BI " __le16 mmctptus;" +.br +.BI " __le32 meb;" +.br +.BI " union {" +.br +.BI " struct nvme_mi_port_pcie pcie;" +.br +.BI " struct nvme_mi_port_smb smb;" +.br +.BI " };" +.br +.BI " +}; +.br + +.SH Members +.IP "portt" 12 +Port Type +.IP "rsvd1" 12 +Reserved +.IP "mmctptus" 12 +Maximum MCTP Transmission Unit Size +.IP "meb" 12 +Management Endpoint Buffer Size +.IP "{unnamed_union}" 12 +anonymous +.IP "pcie" 12 +PCIe Port Specific Data +.IP "smb" 12 +SMBus Port Specific Data diff --git a/doc/man/nvme_mi_read_sc_list.2 b/doc/man/nvme_mi_read_sc_list.2 new file mode 100644 index 0000000..f7b9ba4 --- /dev/null +++ b/doc/man/nvme_mi_read_sc_list.2 @@ -0,0 +1,19 @@ +.TH "libnvme" 9 "struct nvme_mi_read_sc_list" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_mi_read_sc_list \- +.SH SYNOPSIS +struct nvme_mi_read_sc_list { +.br +.BI " __le16 numcmd;" +.br +.BI " struct nvme_mi_osc cmds[];" +.br +.BI " +}; +.br + +.SH Members +.IP "numcmd" 12 +Number of Commands +.IP "cmds" 12 +MEB supported Command Data Structure diff --git a/doc/man/nvme_mi_vpd_hdr.2 b/doc/man/nvme_mi_vpd_hdr.2 new file mode 100644 index 0000000..f3b646d --- /dev/null +++ b/doc/man/nvme_mi_vpd_hdr.2 @@ -0,0 +1,47 @@ +.TH "libnvme" 9 "struct nvme_mi_vpd_hdr" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_mi_vpd_hdr \- +.SH SYNOPSIS +struct nvme_mi_vpd_hdr { +.br +.BI " __u8 ipmiver;" +.br +.BI " __u8 iuaoff;" +.br +.BI " __u8 ciaoff;" +.br +.BI " __u8 biaoff;" +.br +.BI " __u8 piaoff;" +.br +.BI " __u8 mrioff;" +.br +.BI " __u8 rsvd6;" +.br +.BI " __u8 chchk;" +.br +.BI " __u8 vpd[];" +.br +.BI " +}; +.br + +.SH Members +.IP "ipmiver" 12 +IPMI Format Version Number +.IP "iuaoff" 12 +Internal Use Area Starting Offset +.IP "ciaoff" 12 +Chassis Info Area Starting Offset +.IP "biaoff" 12 +Board Info Area Starting Offset +.IP "piaoff" 12 +Product Info Area Starting Offset +.IP "mrioff" 12 +MultiRecord Info Area Starting Offset +.IP "rsvd6" 12 +Reserved +.IP "chchk" 12 +Common Header Checksum +.IP "vpd" 12 +Vital Product Data diff --git a/doc/man/nvme_mi_vpd_mr_common.2 b/doc/man/nvme_mi_vpd_mr_common.2 new file mode 100644 index 0000000..7e8d7a2 --- /dev/null +++ b/doc/man/nvme_mi_vpd_mr_common.2 @@ -0,0 +1,49 @@ +.TH "libnvme" 9 "struct nvme_mi_vpd_mr_common" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_mi_vpd_mr_common \- +.SH SYNOPSIS +struct nvme_mi_vpd_mr_common { +.br +.BI " __u8 type;" +.br +.BI " __u8 rf;" +.br +.BI " __u8 rlen;" +.br +.BI " __u8 rchksum;" +.br +.BI " __u8 hchksum;" +.br +.BI " union {" +.br +.BI " struct nvme_mi_vpd_mra nmra;" +.br +.BI " struct nvme_mi_vpd_ppmra ppmra;" +.br +.BI " struct nvme_mi_vpd_tra tmra;" +.br +.BI " };" +.br +.BI " +}; +.br + +.SH Members +.IP "type" 12 +NVMe Record Type ID +.IP "rf" 12 +Record Format +.IP "rlen" 12 +Record Length +.IP "rchksum" 12 +Record Checksum +.IP "hchksum" 12 +Header Checksum +.IP "{unnamed_union}" 12 +anonymous +.IP "nmra" 12 +NVMe MultiRecord Area +.IP "ppmra" 12 +NVMe PCIe Port MultiRecord Area +.IP "tmra" 12 +Topology MultiRecord Area diff --git a/doc/man/nvme_mi_vpd_mra.2 b/doc/man/nvme_mi_vpd_mra.2 new file mode 100644 index 0000000..6658d62 --- /dev/null +++ b/doc/man/nvme_mi_vpd_mra.2 @@ -0,0 +1,75 @@ +.TH "libnvme" 9 "struct nvme_mi_vpd_mra" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_mi_vpd_mra \- +.SH SYNOPSIS +struct nvme_mi_vpd_mra { +.br +.BI " __u8 nmravn;" +.br +.BI " __u8 ff;" +.br +.BI " __u8 rsvd7[6];" +.br +.BI " __u8 i18vpwr;" +.br +.BI " __u8 m18vpwr;" +.br +.BI " __u8 i33vpwr;" +.br +.BI " __u8 m33vpwr;" +.br +.BI " __u8 rsvd17;" +.br +.BI " __u8 m33vapsr;" +.br +.BI " __u8 i5vapsr;" +.br +.BI " __u8 m5vapsr;" +.br +.BI " __u8 i12vapsr;" +.br +.BI " __u8 m12vapsr;" +.br +.BI " __u8 mtl;" +.br +.BI " __u8 tnvmcap[16];" +.br +.BI " __u8 rsvd37[27];" +.br +.BI " +}; +.br + +.SH Members +.IP "nmravn" 12 +NVMe MultiRecord Area Version Number +.IP "ff" 12 +Form Factor +.IP "rsvd7" 12 +Reserved +.IP "i18vpwr" 12 +Initial 1.8 V Power Supply Requirements +.IP "m18vpwr" 12 +Maximum 1.8 V Power Supply Requirements +.IP "i33vpwr" 12 +Initial 3.3 V Power Supply Requirements +.IP "m33vpwr" 12 +Maximum 3.3 V Power Supply Requirements +.IP "rsvd17" 12 +Reserved +.IP "m33vapsr" 12 +Maximum 3.3 V aux Power Supply Requirements +.IP "i5vapsr" 12 +Initial 5 V Power Supply Requirements +.IP "m5vapsr" 12 +Maximum 5 V Power Supply Requirements +.IP "i12vapsr" 12 +Initial 12 V Power Supply Requirements +.IP "m12vapsr" 12 +Maximum 12 V Power Supply Requirements +.IP "mtl" 12 +Maximum Thermal Load +.IP "tnvmcap" 12 +Total NVM Capacity +.IP "rsvd37" 12 +Reserved diff --git a/doc/man/nvme_mi_vpd_ppmra.2 b/doc/man/nvme_mi_vpd_ppmra.2 new file mode 100644 index 0000000..7e45525 --- /dev/null +++ b/doc/man/nvme_mi_vpd_ppmra.2 @@ -0,0 +1,47 @@ +.TH "libnvme" 9 "struct nvme_mi_vpd_ppmra" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_mi_vpd_ppmra \- +.SH SYNOPSIS +struct nvme_mi_vpd_ppmra { +.br +.BI " __u8 nppmravn;" +.br +.BI " __u8 pn;" +.br +.BI " __u8 ppi;" +.br +.BI " __u8 ls;" +.br +.BI " __u8 mlw;" +.br +.BI " __u8 mctp;" +.br +.BI " __u8 refccap;" +.br +.BI " __u8 pi;" +.br +.BI " __u8 rsvd13[3];" +.br +.BI " +}; +.br + +.SH Members +.IP "nppmravn" 12 +NVMe PCIe Port MultiRecord Area Version Number +.IP "pn" 12 +PCIe Port Number +.IP "ppi" 12 +Port Information +.IP "ls" 12 +PCIe Link Speed +.IP "mlw" 12 +PCIe Maximum Link Width +.IP "mctp" 12 +MCTP Support +.IP "refccap" 12 +Ref Clk Capability +.IP "pi" 12 +Port Identifier +.IP "rsvd13" 12 +Reserved diff --git a/doc/man/nvme_mi_vpd_telem.2 b/doc/man/nvme_mi_vpd_telem.2 new file mode 100644 index 0000000..f7a754b --- /dev/null +++ b/doc/man/nvme_mi_vpd_telem.2 @@ -0,0 +1,28 @@ +.TH "libnvme" 9 "struct nvme_mi_vpd_telem" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_mi_vpd_telem \- +.SH SYNOPSIS +struct nvme_mi_vpd_telem { +.br +.BI " __u8 type;" +.br +.BI " __u8 rev;" +.br +.BI " __u8 len;" +.br +.BI " __u8 data[0];" +.br +.BI " +}; +.br + +.SH Members +.IP "type" 12 +Type of the Element Descriptor +.IP "rev" 12 +Revision of the Element Descriptor +.IP "len" 12 +Number of bytes in the Element Descriptor +.IP "data" 12 +Type-specific information associated with +the Element Descriptor diff --git a/doc/man/nvme_mi_vpd_tra.2 b/doc/man/nvme_mi_vpd_tra.2 new file mode 100644 index 0000000..ed56dcd --- /dev/null +++ b/doc/man/nvme_mi_vpd_tra.2 @@ -0,0 +1,27 @@ +.TH "libnvme" 9 "struct nvme_mi_vpd_tra" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_mi_vpd_tra \- +.SH SYNOPSIS +struct nvme_mi_vpd_tra { +.br +.BI " __u8 vn;" +.br +.BI " __u8 rsvd6;" +.br +.BI " __u8 ec;" +.br +.BI " struct nvme_mi_vpd_telem elems[0];" +.br +.BI " +}; +.br + +.SH Members +.IP "vn" 12 +Version Number +.IP "rsvd6" 12 +Reserved +.IP "ec" 12 +Element Count +.IP "elems" 12 +Element Descriptor diff --git a/doc/man/nvme_namespace_attach_ctrls.2 b/doc/man/nvme_namespace_attach_ctrls.2 new file mode 100644 index 0000000..22657bd --- /dev/null +++ b/doc/man/nvme_namespace_attach_ctrls.2 @@ -0,0 +1,21 @@ +.TH "nvme_namespace_attach_ctrls" 9 "nvme_namespace_attach_ctrls" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_namespace_attach_ctrls \- Attach namespace to controller(s) +.SH SYNOPSIS +.B "int" nvme_namespace_attach_ctrls +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "__u16 num_ctrls " "," +.BI "__u16 *ctrlist " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Namespace ID to attach +.IP "num_ctrls" 12 +Number of controllers in ctrlist +.IP "ctrlist" 12 +List of controller IDs to perform the attach action +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_namespace_detach_ctrls.2 b/doc/man/nvme_namespace_detach_ctrls.2 new file mode 100644 index 0000000..2d18cc5 --- /dev/null +++ b/doc/man/nvme_namespace_detach_ctrls.2 @@ -0,0 +1,21 @@ +.TH "nvme_namespace_detach_ctrls" 9 "nvme_namespace_detach_ctrls" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_namespace_detach_ctrls \- Detach namespace from controller(s) +.SH SYNOPSIS +.B "int" nvme_namespace_detach_ctrls +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "__u16 num_ctrls " "," +.BI "__u16 *ctrlist " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Namespace ID to detach +.IP "num_ctrls" 12 +Number of controllers in ctrlist +.IP "ctrlist" 12 +List of controller IDs to perform the detach action +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_namespace_filter.2 b/doc/man/nvme_namespace_filter.2 new file mode 100644 index 0000000..5536b95 --- /dev/null +++ b/doc/man/nvme_namespace_filter.2 @@ -0,0 +1,11 @@ +.TH "nvme_namespace_filter" 9 "nvme_namespace_filter" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_namespace_filter \- Filter for namespaces +.SH SYNOPSIS +.B "int" nvme_namespace_filter +.BI "(const struct dirent *d " ");" +.SH ARGUMENTS +.IP "d" 12 +dirent to check +.SH "RETURN" +1 if \fId\fP matches, 0 otherwise diff --git a/doc/man/nvme_namespace_first_path.2 b/doc/man/nvme_namespace_first_path.2 new file mode 100644 index 0000000..faaace8 --- /dev/null +++ b/doc/man/nvme_namespace_first_path.2 @@ -0,0 +1,11 @@ +.TH "nvme_namespace_first_path" 9 "nvme_namespace_first_path" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_namespace_first_path \- Start path iterator +.SH SYNOPSIS +.B "nvme_path_t" nvme_namespace_first_path +.BI "(nvme_ns_t ns " ");" +.SH ARGUMENTS +.IP "ns" 12 +Namespace instance +.SH "RETURN" +First \fInvme_path_t\fP object of an \fIns\fP iterator diff --git a/doc/man/nvme_namespace_for_each_path.2 b/doc/man/nvme_namespace_for_each_path.2 new file mode 100644 index 0000000..c86bb59 --- /dev/null +++ b/doc/man/nvme_namespace_for_each_path.2 @@ -0,0 +1,12 @@ +.TH "nvme_namespace_for_each_path" 9 "nvme_namespace_for_each_path" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_namespace_for_each_path \- Traverse paths +.SH SYNOPSIS +.B "nvme_namespace_for_each_path +.BI "(c " "," +.BI "p " ");" +.SH ARGUMENTS +.IP "c" 12 +-- undescribed -- +.IP "p" 12 +\fInvme_path_t\fP object diff --git a/doc/man/nvme_namespace_for_each_path_safe.2 b/doc/man/nvme_namespace_for_each_path_safe.2 new file mode 100644 index 0000000..9202a27 --- /dev/null +++ b/doc/man/nvme_namespace_for_each_path_safe.2 @@ -0,0 +1,15 @@ +.TH "nvme_namespace_for_each_path_safe" 9 "nvme_namespace_for_each_path_safe" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_namespace_for_each_path_safe \- Traverse paths +.SH SYNOPSIS +.B "nvme_namespace_for_each_path_safe +.BI "(n " "," +.BI "p " "," +.BI "_p " ");" +.SH ARGUMENTS +.IP "n" 12 +-- undescribed -- +.IP "p" 12 +\fInvme_path_t\fP object +.IP "_p" 12 +A \fInvme_path_t_node\fP to use as temporary storage diff --git a/doc/man/nvme_namespace_next_path.2 b/doc/man/nvme_namespace_next_path.2 new file mode 100644 index 0000000..a380df3 --- /dev/null +++ b/doc/man/nvme_namespace_next_path.2 @@ -0,0 +1,14 @@ +.TH "nvme_namespace_next_path" 9 "nvme_namespace_next_path" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_namespace_next_path \- Next path iterator +.SH SYNOPSIS +.B "nvme_path_t" nvme_namespace_next_path +.BI "(nvme_ns_t c " "," +.BI "nvme_path_t p " ");" +.SH ARGUMENTS +.IP "c" 12 +-- undescribed -- +.IP "p" 12 +Previous \fInvme_path_t\fP object of an \fIns\fP iterator +.SH "RETURN" +Next \fInvme_path_t\fP object of an \fIns\fP iterator diff --git a/doc/man/nvme_nd_ns_fpi.2 b/doc/man/nvme_nd_ns_fpi.2 new file mode 100644 index 0000000..b3dfa5b --- /dev/null +++ b/doc/man/nvme_nd_ns_fpi.2 @@ -0,0 +1,19 @@ +.TH "libnvme" 9 "enum nvme_nd_ns_fpi" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_nd_ns_fpi \- If a format operation is in progress, this field indicates the percentage of the namespace that remains to be formatted. +.SH SYNOPSIS +enum nvme_nd_ns_fpi { +.br +.BI " NVME_NS_FPI_REMAINING" +, +.br +.br +.BI " NVME_NS_FPI_SUPPORTED" + +}; +.SH Constants +.IP "NVME_NS_FPI_REMAINING" 12 +Mask to get the format percent remaining value +.IP "NVME_NS_FPI_SUPPORTED" 12 +If set, indicates that the namespace supports the +Format Progress Indicator defined for the field. diff --git a/doc/man/nvme_next_host.2 b/doc/man/nvme_next_host.2 new file mode 100644 index 0000000..39cbf31 --- /dev/null +++ b/doc/man/nvme_next_host.2 @@ -0,0 +1,14 @@ +.TH "nvme_next_host" 9 "nvme_next_host" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_next_host \- Next host iterator +.SH SYNOPSIS +.B "nvme_host_t" nvme_next_host +.BI "(nvme_root_t r " "," +.BI "nvme_host_t h " ");" +.SH ARGUMENTS +.IP "r" 12 +\fInvme_root_t\fP object +.IP "h" 12 +Previous \fInvme_host_t\fP iterator +.SH "RETURN" +Next \fInvme_host_t\fP object in an iterator diff --git a/doc/man/nvme_next_subsystem.2 b/doc/man/nvme_next_subsystem.2 new file mode 100644 index 0000000..d6a0b32 --- /dev/null +++ b/doc/man/nvme_next_subsystem.2 @@ -0,0 +1,14 @@ +.TH "nvme_next_subsystem" 9 "nvme_next_subsystem" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_next_subsystem \- Next subsystem iterator +.SH SYNOPSIS +.B "nvme_subsystem_t" nvme_next_subsystem +.BI "(nvme_host_t h " "," +.BI "nvme_subsystem_t s " ");" +.SH ARGUMENTS +.IP "h" 12 +\fInvme_host_t\fP object +.IP "s" 12 +Previous \fInvme_subsystem_t\fP iterator +.SH "RETURN" +next \fInvme_subsystem_t\fP object in an iterator diff --git a/doc/man/nvme_ns_attach.2 b/doc/man/nvme_ns_attach.2 new file mode 100644 index 0000000..806998c --- /dev/null +++ b/doc/man/nvme_ns_attach.2 @@ -0,0 +1,9 @@ +.TH "nvme_ns_attach" 9 "nvme_ns_attach" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_attach \- Attach or detach namespace to controller(s) +.SH SYNOPSIS +.B "int" nvme_ns_attach +.BI "(struct nvme_ns_attach_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_ns_attach_args\fP Argument structure diff --git a/doc/man/nvme_ns_attach_args.2 b/doc/man/nvme_ns_attach_args.2 new file mode 100644 index 0000000..00f2d14 --- /dev/null +++ b/doc/man/nvme_ns_attach_args.2 @@ -0,0 +1,39 @@ +.TH "libnvme" 9 "struct nvme_ns_attach_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_ns_attach_args \- Arguments for Nvme Namespace Management command +.SH SYNOPSIS +struct nvme_ns_attach_args { +.br +.BI " __u32 *result;" +.br +.BI " struct nvme_ctrl_list *ctrlist;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u32 nsid;" +.br +.BI " enum nvme_ns_attach_sel sel;" +.br +.BI " +}; +.br + +.SH Members +.IP "result" 12 +NVMe command result +.IP "ctrlist" 12 +Controller list to modify attachment state of nsid +.IP "args_size" 12 +Size of \fIstruct nvme_ns_attach_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "nsid" 12 +Namespace ID to execute attach selection +.IP "sel" 12 +Attachment selection, see \fIenum nvme_ns_attach_sel\fP diff --git a/doc/man/nvme_ns_attach_ctrls.2 b/doc/man/nvme_ns_attach_ctrls.2 new file mode 100644 index 0000000..b28ddb3 --- /dev/null +++ b/doc/man/nvme_ns_attach_ctrls.2 @@ -0,0 +1,15 @@ +.TH "nvme_ns_attach_ctrls" 9 "nvme_ns_attach_ctrls" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_attach_ctrls \- +.SH SYNOPSIS +.B "int" nvme_ns_attach_ctrls +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "struct nvme_ctrl_list *ctrlist " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Namespace ID to attach +.IP "ctrlist" 12 +Controller list to modify attachment state of nsid diff --git a/doc/man/nvme_ns_attach_sel.2 b/doc/man/nvme_ns_attach_sel.2 new file mode 100644 index 0000000..b3e0386 --- /dev/null +++ b/doc/man/nvme_ns_attach_sel.2 @@ -0,0 +1,18 @@ +.TH "libnvme" 9 "enum nvme_ns_attach_sel" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_ns_attach_sel \- +.SH SYNOPSIS +enum nvme_ns_attach_sel { +.br +.BI " NVME_NS_ATTACH_SEL_CTRL_ATTACH" +, +.br +.br +.BI " NVME_NS_ATTACH_SEL_CTRL_DEATTACH" + +}; +.SH Constants +.IP "NVME_NS_ATTACH_SEL_CTRL_ATTACH" 12 +Namespace attach selection +.IP "NVME_NS_ATTACH_SEL_CTRL_DEATTACH" 12 +Namespace detach selection diff --git a/doc/man/nvme_ns_compare.2 b/doc/man/nvme_ns_compare.2 new file mode 100644 index 0000000..0c1d267 --- /dev/null +++ b/doc/man/nvme_ns_compare.2 @@ -0,0 +1,20 @@ +.TH "nvme_ns_compare" 9 "nvme_ns_compare" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_compare \- Compare data on a namespace +.SH SYNOPSIS +.B "int" nvme_ns_compare +.BI "(nvme_ns_t n " "," +.BI "void *buf " "," +.BI "off_t offset " "," +.BI "size_t count " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.IP "buf" 12 +Buffer with data to be compared +.IP "offset" 12 +LBA offset of \fIn\fP +.IP "count" 12 +Number of sectors in \fIbuf\fP +.SH "RETURN" +Number of sectors compared diff --git a/doc/man/nvme_ns_detach_ctrls.2 b/doc/man/nvme_ns_detach_ctrls.2 new file mode 100644 index 0000000..28ea6f3 --- /dev/null +++ b/doc/man/nvme_ns_detach_ctrls.2 @@ -0,0 +1,15 @@ +.TH "nvme_ns_detach_ctrls" 9 "nvme_ns_detach_ctrls" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_detach_ctrls \- +.SH SYNOPSIS +.B "int" nvme_ns_detach_ctrls +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "struct nvme_ctrl_list *ctrlist " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Namespace ID to detach +.IP "ctrlist" 12 +Controller list to modify attachment state of nsid diff --git a/doc/man/nvme_ns_flush.2 b/doc/man/nvme_ns_flush.2 new file mode 100644 index 0000000..c7cab3a --- /dev/null +++ b/doc/man/nvme_ns_flush.2 @@ -0,0 +1,11 @@ +.TH "nvme_ns_flush" 9 "nvme_ns_flush" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_flush \- Flush data to a namespace +.SH SYNOPSIS +.B "int" nvme_ns_flush +.BI "(nvme_ns_t n " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.SH "RETURN" +0 on success, -1 on error. diff --git a/doc/man/nvme_ns_get_csi.2 b/doc/man/nvme_ns_get_csi.2 new file mode 100644 index 0000000..b8ba92f --- /dev/null +++ b/doc/man/nvme_ns_get_csi.2 @@ -0,0 +1,11 @@ +.TH "nvme_ns_get_csi" 9 "nvme_ns_get_csi" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_get_csi \- Command set identifier of a namespace +.SH SYNOPSIS +.B "enum nvme_csi" nvme_ns_get_csi +.BI "(nvme_ns_t n " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.SH "RETURN" +The namespace's command set identifier in use diff --git a/doc/man/nvme_ns_get_ctrl.2 b/doc/man/nvme_ns_get_ctrl.2 new file mode 100644 index 0000000..fb3467c --- /dev/null +++ b/doc/man/nvme_ns_get_ctrl.2 @@ -0,0 +1,13 @@ +.TH "nvme_ns_get_ctrl" 9 "nvme_ns_get_ctrl" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_get_ctrl \- &nvme_ctrl_t of a namespace +.SH SYNOPSIS +.B "nvme_ctrl_t" nvme_ns_get_ctrl +.BI "(nvme_ns_t n " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.SH "DESCRIPTION" +nvme_ctrl_t object may be NULL for a multipathed namespace +.SH "RETURN" +nvme_ctrl_t object of \fIn\fP if present diff --git a/doc/man/nvme_ns_get_fd.2 b/doc/man/nvme_ns_get_fd.2 new file mode 100644 index 0000000..95c199e --- /dev/null +++ b/doc/man/nvme_ns_get_fd.2 @@ -0,0 +1,11 @@ +.TH "nvme_ns_get_fd" 9 "nvme_ns_get_fd" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_get_fd \- Get associated filedescriptor +.SH SYNOPSIS +.B "int" nvme_ns_get_fd +.BI "(nvme_ns_t n " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.SH "RETURN" +File descriptor associated with \fIn\fP or -1 diff --git a/doc/man/nvme_ns_get_firmware.2 b/doc/man/nvme_ns_get_firmware.2 new file mode 100644 index 0000000..cc721c7 --- /dev/null +++ b/doc/man/nvme_ns_get_firmware.2 @@ -0,0 +1,11 @@ +.TH "nvme_ns_get_firmware" 9 "nvme_ns_get_firmware" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_get_firmware \- Firmware string of a namespace +.SH SYNOPSIS +.B "const char *" nvme_ns_get_firmware +.BI "(nvme_ns_t n " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.SH "RETURN" +Firmware string of \fIn\fP diff --git a/doc/man/nvme_ns_get_generic_name.2 b/doc/man/nvme_ns_get_generic_name.2 new file mode 100644 index 0000000..58176ca --- /dev/null +++ b/doc/man/nvme_ns_get_generic_name.2 @@ -0,0 +1,11 @@ +.TH "nvme_ns_get_generic_name" 9 "nvme_ns_get_generic_name" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_get_generic_name \- Returns name of generic namespace chardev. +.SH SYNOPSIS +.B "const char *" nvme_ns_get_generic_name +.BI "(nvme_ns_t n " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.SH "RETURN" +Name of generic namespace chardev diff --git a/doc/man/nvme_ns_get_lba_count.2 b/doc/man/nvme_ns_get_lba_count.2 new file mode 100644 index 0000000..7d3c172 --- /dev/null +++ b/doc/man/nvme_ns_get_lba_count.2 @@ -0,0 +1,11 @@ +.TH "nvme_ns_get_lba_count" 9 "nvme_ns_get_lba_count" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_get_lba_count \- LBA count of a namespace +.SH SYNOPSIS +.B "uint64_t" nvme_ns_get_lba_count +.BI "(nvme_ns_t n " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.SH "RETURN" +LBA count of \fIn\fP diff --git a/doc/man/nvme_ns_get_lba_size.2 b/doc/man/nvme_ns_get_lba_size.2 new file mode 100644 index 0000000..62f3850 --- /dev/null +++ b/doc/man/nvme_ns_get_lba_size.2 @@ -0,0 +1,11 @@ +.TH "nvme_ns_get_lba_size" 9 "nvme_ns_get_lba_size" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_get_lba_size \- LBA size of a namespace +.SH SYNOPSIS +.B "int" nvme_ns_get_lba_size +.BI "(nvme_ns_t n " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.SH "RETURN" +LBA size of \fIn\fP diff --git a/doc/man/nvme_ns_get_lba_util.2 b/doc/man/nvme_ns_get_lba_util.2 new file mode 100644 index 0000000..52eac40 --- /dev/null +++ b/doc/man/nvme_ns_get_lba_util.2 @@ -0,0 +1,11 @@ +.TH "nvme_ns_get_lba_util" 9 "nvme_ns_get_lba_util" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_get_lba_util \- LBA utilisation of a namespace +.SH SYNOPSIS +.B "uint64_t" nvme_ns_get_lba_util +.BI "(nvme_ns_t n " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.SH "RETURN" +LBA utilisation of \fIn\fP diff --git a/doc/man/nvme_ns_get_meta_size.2 b/doc/man/nvme_ns_get_meta_size.2 new file mode 100644 index 0000000..7cd756a --- /dev/null +++ b/doc/man/nvme_ns_get_meta_size.2 @@ -0,0 +1,11 @@ +.TH "nvme_ns_get_meta_size" 9 "nvme_ns_get_meta_size" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_get_meta_size \- Metadata size of a namespace +.SH SYNOPSIS +.B "int" nvme_ns_get_meta_size +.BI "(nvme_ns_t n " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.SH "RETURN" +Metadata size of \fIn\fP diff --git a/doc/man/nvme_ns_get_model.2 b/doc/man/nvme_ns_get_model.2 new file mode 100644 index 0000000..3ca02f4 --- /dev/null +++ b/doc/man/nvme_ns_get_model.2 @@ -0,0 +1,11 @@ +.TH "nvme_ns_get_model" 9 "nvme_ns_get_model" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_get_model \- Model of a namespace +.SH SYNOPSIS +.B "const char *" nvme_ns_get_model +.BI "(nvme_ns_t n " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.SH "RETURN" +Model string of \fIn\fP diff --git a/doc/man/nvme_ns_get_name.2 b/doc/man/nvme_ns_get_name.2 new file mode 100644 index 0000000..d4cf500 --- /dev/null +++ b/doc/man/nvme_ns_get_name.2 @@ -0,0 +1,11 @@ +.TH "nvme_ns_get_name" 9 "nvme_ns_get_name" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_get_name \- sysfs name of a namespace +.SH SYNOPSIS +.B "const char *" nvme_ns_get_name +.BI "(nvme_ns_t n " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.SH "RETURN" +sysfs name of \fIn\fP diff --git a/doc/man/nvme_ns_get_nguid.2 b/doc/man/nvme_ns_get_nguid.2 new file mode 100644 index 0000000..43bb47c --- /dev/null +++ b/doc/man/nvme_ns_get_nguid.2 @@ -0,0 +1,11 @@ +.TH "nvme_ns_get_nguid" 9 "nvme_ns_get_nguid" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_get_nguid \- 128-bit nguid of a namespace +.SH SYNOPSIS +.B "const uint8_t *" nvme_ns_get_nguid +.BI "(nvme_ns_t n " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.SH "RETURN" +A pointer to the 128-bit nguid diff --git a/doc/man/nvme_ns_get_nsid.2 b/doc/man/nvme_ns_get_nsid.2 new file mode 100644 index 0000000..2904471 --- /dev/null +++ b/doc/man/nvme_ns_get_nsid.2 @@ -0,0 +1,11 @@ +.TH "nvme_ns_get_nsid" 9 "nvme_ns_get_nsid" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_get_nsid \- NSID of a namespace +.SH SYNOPSIS +.B "int" nvme_ns_get_nsid +.BI "(nvme_ns_t n " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.SH "RETURN" +NSID of \fIn\fP diff --git a/doc/man/nvme_ns_get_serial.2 b/doc/man/nvme_ns_get_serial.2 new file mode 100644 index 0000000..cafedd7 --- /dev/null +++ b/doc/man/nvme_ns_get_serial.2 @@ -0,0 +1,11 @@ +.TH "nvme_ns_get_serial" 9 "nvme_ns_get_serial" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_get_serial \- Serial number of a namespace +.SH SYNOPSIS +.B "const char *" nvme_ns_get_serial +.BI "(nvme_ns_t n " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.SH "RETURN" +Serial number string of \fIn\fP diff --git a/doc/man/nvme_ns_get_subsystem.2 b/doc/man/nvme_ns_get_subsystem.2 new file mode 100644 index 0000000..b9404ad --- /dev/null +++ b/doc/man/nvme_ns_get_subsystem.2 @@ -0,0 +1,11 @@ +.TH "nvme_ns_get_subsystem" 9 "nvme_ns_get_subsystem" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_get_subsystem \- &nvme_subsystem_t of a namespace +.SH SYNOPSIS +.B "nvme_subsystem_t" nvme_ns_get_subsystem +.BI "(nvme_ns_t n " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.SH "RETURN" +nvme_subsystem_t object of \fIn\fP diff --git a/doc/man/nvme_ns_get_sysfs_dir.2 b/doc/man/nvme_ns_get_sysfs_dir.2 new file mode 100644 index 0000000..5ff53f5 --- /dev/null +++ b/doc/man/nvme_ns_get_sysfs_dir.2 @@ -0,0 +1,11 @@ +.TH "nvme_ns_get_sysfs_dir" 9 "nvme_ns_get_sysfs_dir" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_get_sysfs_dir \- sysfs directory of a namespace +.SH SYNOPSIS +.B "const char *" nvme_ns_get_sysfs_dir +.BI "(nvme_ns_t n " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.SH "RETURN" +sysfs directory name of \fIn\fP diff --git a/doc/man/nvme_ns_get_uuid.2 b/doc/man/nvme_ns_get_uuid.2 new file mode 100644 index 0000000..ee0c607 --- /dev/null +++ b/doc/man/nvme_ns_get_uuid.2 @@ -0,0 +1,14 @@ +.TH "nvme_ns_get_uuid" 9 "nvme_ns_get_uuid" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_get_uuid \- UUID of a namespace +.SH SYNOPSIS +.B "void" nvme_ns_get_uuid +.BI "(nvme_ns_t n " "," +.BI "uuid_t out " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.IP "out" 12 +buffer for the UUID +.SH "DESCRIPTION" +Copies the namespace's uuid into \fIout\fP diff --git a/doc/man/nvme_ns_id_desc.2 b/doc/man/nvme_ns_id_desc.2 new file mode 100644 index 0000000..2116046 --- /dev/null +++ b/doc/man/nvme_ns_id_desc.2 @@ -0,0 +1,30 @@ +.TH "libnvme" 9 "struct nvme_ns_id_desc" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_ns_id_desc \- +.SH SYNOPSIS +struct nvme_ns_id_desc { +.br +.BI " __u8 nidt;" +.br +.BI " __u8 nidl;" +.br +.BI " __le16 rsvd;" +.br +.BI " __u8 nid[];" +.br +.BI " +}; +.br + +.SH Members +.IP "nidt" 12 +Namespace Identifier Type, see \fIenum nvme_ns_id_desc_nidt\fP +.IP "nidl" 12 +Namespace Identifier Length contains the length in bytes of the +\fIstruct nvme_id_ns\fP.nid. +.IP "rsvd" 12 +Reserved +.IP "nid" 12 +Namespace Identifier contains a value that is globally unique and +assigned to the namespace when the namespace is created. The length +is defined in \fIstruct nvme_id_ns\fP.nidl. diff --git a/doc/man/nvme_ns_id_desc_nidt.2 b/doc/man/nvme_ns_id_desc_nidt.2 new file mode 100644 index 0000000..eb399b1 --- /dev/null +++ b/doc/man/nvme_ns_id_desc_nidt.2 @@ -0,0 +1,33 @@ +.TH "libnvme" 9 "enum nvme_ns_id_desc_nidt" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_ns_id_desc_nidt \- Known namespace identifier types +.SH SYNOPSIS +enum nvme_ns_id_desc_nidt { +.br +.BI " NVME_NIDT_EUI64" +, +.br +.br +.BI " NVME_NIDT_NGUID" +, +.br +.br +.BI " NVME_NIDT_UUID" +, +.br +.br +.BI " NVME_NIDT_CSI" + +}; +.SH Constants +.IP "NVME_NIDT_EUI64" 12 +IEEE Extended Unique Identifier, the NID field contains a +copy of the EUI64 field in the struct nvme_id_ns.eui64. +.IP "NVME_NIDT_NGUID" 12 +Namespace Globally Unique Identifier, the NID field +contains a copy of the NGUID field in struct nvme_id_ns.nguid. +.IP "NVME_NIDT_UUID" 12 +The NID field contains a 128-bit Universally Unique +Identifier (UUID) as specified in RFC 4122. +.IP "NVME_NIDT_CSI" 12 +The NID field contains the command set indentifier. diff --git a/doc/man/nvme_ns_identify.2 b/doc/man/nvme_ns_identify.2 new file mode 100644 index 0000000..0aa1e53 --- /dev/null +++ b/doc/man/nvme_ns_identify.2 @@ -0,0 +1,17 @@ +.TH "nvme_ns_identify" 9 "nvme_ns_identify" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_identify \- Issue an 'identify namespace' command +.SH SYNOPSIS +.B "int" nvme_ns_identify +.BI "(nvme_ns_t n " "," +.BI "struct nvme_id_ns *ns " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.IP "ns" 12 +\fInvme_id_ns\fP buffer +.SH "DESCRIPTION" +Writes the data returned by the 'identify namespace' command +into \fIns\fP. +.SH "RETURN" +0 on success, -1 on error. diff --git a/doc/man/nvme_ns_identify_descs.2 b/doc/man/nvme_ns_identify_descs.2 new file mode 100644 index 0000000..e7a8e68 --- /dev/null +++ b/doc/man/nvme_ns_identify_descs.2 @@ -0,0 +1,17 @@ +.TH "nvme_ns_identify_descs" 9 "nvme_ns_identify_descs" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_identify_descs \- Issue an 'identify descriptors' command +.SH SYNOPSIS +.B "int" nvme_ns_identify_descs +.BI "(nvme_ns_t n " "," +.BI "struct nvme_ns_id_desc *descs " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.IP "descs" 12 +List of identify descriptors +.SH "DESCRIPTION" +Writes the data returned by the 'identify descriptors' command +into \fIdescs\fP. +.SH "RETURN" +0 on success, -1 on error. diff --git a/doc/man/nvme_ns_list.2 b/doc/man/nvme_ns_list.2 new file mode 100644 index 0000000..92943a0 --- /dev/null +++ b/doc/man/nvme_ns_list.2 @@ -0,0 +1,15 @@ +.TH "libnvme" 9 "struct nvme_ns_list" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_ns_list \- +.SH SYNOPSIS +struct nvme_ns_list { +.br +.BI " __le32 ns[NVME_ID_NS_LIST_MAX];" +.br +.BI " +}; +.br + +.SH Members +.IP "ns" 12 +Namespace Identifier diff --git a/doc/man/nvme_ns_metadata_type.2 b/doc/man/nvme_ns_metadata_type.2 new file mode 100644 index 0000000..7de5c2d --- /dev/null +++ b/doc/man/nvme_ns_metadata_type.2 @@ -0,0 +1,34 @@ +.TH "libnvme" 9 "enum nvme_ns_metadata_type" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_ns_metadata_type \- Namespace Metadata Element Types +.SH SYNOPSIS +enum nvme_ns_metadata_type { +.br +.BI " NVME_NS_METADATA_OS_NS_NAME" +, +.br +.br +.BI " NVME_NS_METADATA_PRE_BOOT_NS_NAME" +, +.br +.br +.BI " NVME_NS_METADATA_OS_NS_QUAL_1" +, +.br +.br +.BI " NVME_NS_METADATA_OS_NS_QUAL_2" + +}; +.SH Constants +.IP "NVME_NS_METADATA_OS_NS_NAME" 12 +Name of the namespace in the the +operating system +.IP "NVME_NS_METADATA_PRE_BOOT_NS_NAME" 12 +Name of the namespace in the pre-boot +environment. +.IP "NVME_NS_METADATA_OS_NS_QUAL_1" 12 +First qualifier of the Operating System +Namespace Name. +.IP "NVME_NS_METADATA_OS_NS_QUAL_2" 12 +Second qualifier of the Operating System +Namespace Name. diff --git a/doc/man/nvme_ns_mgmt.2 b/doc/man/nvme_ns_mgmt.2 new file mode 100644 index 0000000..8916910 --- /dev/null +++ b/doc/man/nvme_ns_mgmt.2 @@ -0,0 +1,9 @@ +.TH "nvme_ns_mgmt" 9 "nvme_ns_mgmt" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_mgmt \- Issue a Namespace management command +.SH SYNOPSIS +.B "int" nvme_ns_mgmt +.BI "(struct nvme_ns_mgmt_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_ns_mgmt_args\fP Argument structure diff --git a/doc/man/nvme_ns_mgmt_args.2 b/doc/man/nvme_ns_mgmt_args.2 new file mode 100644 index 0000000..9231c78 --- /dev/null +++ b/doc/man/nvme_ns_mgmt_args.2 @@ -0,0 +1,43 @@ +.TH "libnvme" 9 "struct nvme_ns_mgmt_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_ns_mgmt_args \- Arguments for NVMe Namespace Management command +.SH SYNOPSIS +struct nvme_ns_mgmt_args { +.br +.BI " __u32 *result;" +.br +.BI " struct nvme_id_ns *ns;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u32 nsid;" +.br +.BI " enum nvme_ns_mgmt_sel sel;" +.br +.BI " __u8 csi;" +.br +.BI " +}; +.br + +.SH Members +.IP "result" 12 +NVMe command result +.IP "ns" 12 +Namespace identication descriptors +.IP "args_size" 12 +Size of \fIstruct nvme_ns_mgmt_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "nsid" 12 +Namespace identifier +.IP "sel" 12 +Type of management operation to perform +.IP "csi" 12 +Command Set Identifier diff --git a/doc/man/nvme_ns_mgmt_create.2 b/doc/man/nvme_ns_mgmt_create.2 new file mode 100644 index 0000000..479d146 --- /dev/null +++ b/doc/man/nvme_ns_mgmt_create.2 @@ -0,0 +1,29 @@ +.TH "nvme_ns_mgmt_create" 9 "nvme_ns_mgmt_create" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_mgmt_create \- +.SH SYNOPSIS +.B "int" nvme_ns_mgmt_create +.BI "(int fd " "," +.BI "struct nvme_id_ns *ns " "," +.BI "__u32 *nsid " "," +.BI "__u32 timeout " "," +.BI "__u8 csi " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "ns" 12 +Namespace identification that defines ns creation parameters +.IP "nsid" 12 +On success, set to the namespace id that was created +.IP "timeout" 12 +Overide the default timeout to this value in milliseconds; +set to 0 to use the system default. +.IP "csi" 12 +Command Set Identifier +.SH "DESCRIPTION" +On successful creation, the namespace exists in the subsystem, but is not +attached to any controller. Use the \fBnvme_ns_attach_ctrls\fP to assign the +namespace to one or more controllers. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_ns_mgmt_delete.2 b/doc/man/nvme_ns_mgmt_delete.2 new file mode 100644 index 0000000..dcbf3f0 --- /dev/null +++ b/doc/man/nvme_ns_mgmt_delete.2 @@ -0,0 +1,19 @@ +.TH "nvme_ns_mgmt_delete" 9 "nvme_ns_mgmt_delete" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_mgmt_delete \- +.SH SYNOPSIS +.B "int" nvme_ns_mgmt_delete +.BI "(int fd " "," +.BI "__u32 nsid " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Namespace identifier to delete +.SH "DESCRIPTION" +It is recommended that a namespace being deleted is not attached to any +controller. Use the \fBnvme_ns_detach_ctrls\fP first if the namespace is still +attached. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_ns_mgmt_sel.2 b/doc/man/nvme_ns_mgmt_sel.2 new file mode 100644 index 0000000..8683f3b --- /dev/null +++ b/doc/man/nvme_ns_mgmt_sel.2 @@ -0,0 +1,18 @@ +.TH "libnvme" 9 "enum nvme_ns_mgmt_sel" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_ns_mgmt_sel \- +.SH SYNOPSIS +enum nvme_ns_mgmt_sel { +.br +.BI " NVME_NS_MGMT_SEL_CREATE" +, +.br +.br +.BI " NVME_NS_MGMT_SEL_DELETE" + +}; +.SH Constants +.IP "NVME_NS_MGMT_SEL_CREATE" 12 +Namespace Create selection +.IP "NVME_NS_MGMT_SEL_DELETE" 12 +Namespace Delete selection diff --git a/doc/man/nvme_ns_read.2 b/doc/man/nvme_ns_read.2 new file mode 100644 index 0000000..b6d8441 --- /dev/null +++ b/doc/man/nvme_ns_read.2 @@ -0,0 +1,20 @@ +.TH "nvme_ns_read" 9 "nvme_ns_read" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_read \- Read from a namespace +.SH SYNOPSIS +.B "int" nvme_ns_read +.BI "(nvme_ns_t n " "," +.BI "void *buf " "," +.BI "off_t offset " "," +.BI "size_t count " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.IP "buf" 12 +Buffer into which the data will be transferred +.IP "offset" 12 +LBA offset of \fIn\fP +.IP "count" 12 +Number of sectors in \fIbuf\fP +.SH "RETURN" +Number of sectors read or -1 on error. diff --git a/doc/man/nvme_ns_rescan.2 b/doc/man/nvme_ns_rescan.2 new file mode 100644 index 0000000..c0334d3 --- /dev/null +++ b/doc/man/nvme_ns_rescan.2 @@ -0,0 +1,13 @@ +.TH "nvme_ns_rescan" 9 "nvme_ns_rescan" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_rescan \- Initiate a controller rescan +.SH SYNOPSIS +.B "int" nvme_ns_rescan +.BI "(int fd " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.SH "DESCRIPTION" +This should only be sent to controller handles, not to namespaces. +.SH "RETURN" +0 if a rescan was initiated or -1 with errno set otherwise. diff --git a/doc/man/nvme_ns_verify.2 b/doc/man/nvme_ns_verify.2 new file mode 100644 index 0000000..1f669ad --- /dev/null +++ b/doc/man/nvme_ns_verify.2 @@ -0,0 +1,17 @@ +.TH "nvme_ns_verify" 9 "nvme_ns_verify" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_verify \- Verify data on a namespace +.SH SYNOPSIS +.B "int" nvme_ns_verify +.BI "(nvme_ns_t n " "," +.BI "off_t offset " "," +.BI "size_t count " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.IP "offset" 12 +LBA offset of \fIn\fP +.IP "count" 12 +Number of sectors to be verified +.SH "RETURN" +Number of sectors verified diff --git a/doc/man/nvme_ns_write.2 b/doc/man/nvme_ns_write.2 new file mode 100644 index 0000000..132ea2c --- /dev/null +++ b/doc/man/nvme_ns_write.2 @@ -0,0 +1,20 @@ +.TH "nvme_ns_write" 9 "nvme_ns_write" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_write \- Write to a namespace +.SH SYNOPSIS +.B "int" nvme_ns_write +.BI "(nvme_ns_t n " "," +.BI "void *buf " "," +.BI "off_t offset " "," +.BI "size_t count " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.IP "buf" 12 +Buffer with data to be written +.IP "offset" 12 +LBA offset of \fIn\fP +.IP "count" 12 +Number of sectors in \fIbuf\fP +.SH "RETURN" +Number of sectors written or -1 on error diff --git a/doc/man/nvme_ns_write_protect_cfg.2 b/doc/man/nvme_ns_write_protect_cfg.2 new file mode 100644 index 0000000..5a8dc11 --- /dev/null +++ b/doc/man/nvme_ns_write_protect_cfg.2 @@ -0,0 +1,30 @@ +.TH "libnvme" 9 "enum nvme_ns_write_protect_cfg" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_ns_write_protect_cfg \- +.SH SYNOPSIS +enum nvme_ns_write_protect_cfg { +.br +.BI " NVME_NS_WP_CFG_NONE" +, +.br +.br +.BI " NVME_NS_WP_CFG_PROTECT" +, +.br +.br +.BI " NVME_NS_WP_CFG_PROTECT_POWER_CYCLE" +, +.br +.br +.BI " NVME_NS_WP_CFG_PROTECT_PERMANENT" + +}; +.SH Constants +.IP "NVME_NS_WP_CFG_NONE" 12 +No Write Protect +.IP "NVME_NS_WP_CFG_PROTECT" 12 +Write Protect +.IP "NVME_NS_WP_CFG_PROTECT_POWER_CYCLE" 12 +Write Protect Until Power Cycle +.IP "NVME_NS_WP_CFG_PROTECT_PERMANENT" 12 +Permanent Write Protect diff --git a/doc/man/nvme_ns_write_uncorrectable.2 b/doc/man/nvme_ns_write_uncorrectable.2 new file mode 100644 index 0000000..b6de816 --- /dev/null +++ b/doc/man/nvme_ns_write_uncorrectable.2 @@ -0,0 +1,17 @@ +.TH "nvme_ns_write_uncorrectable" 9 "nvme_ns_write_uncorrectable" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_write_uncorrectable \- Issus a 'write uncorrectable' command +.SH SYNOPSIS +.B "int" nvme_ns_write_uncorrectable +.BI "(nvme_ns_t n " "," +.BI "off_t offset " "," +.BI "size_t count " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.IP "offset" 12 +LBA offset in \fIn\fP +.IP "count" 12 +Number of sectors to be written +.SH "RETURN" +Number of sectors written diff --git a/doc/man/nvme_ns_write_zeros.2 b/doc/man/nvme_ns_write_zeros.2 new file mode 100644 index 0000000..ee2c2d1 --- /dev/null +++ b/doc/man/nvme_ns_write_zeros.2 @@ -0,0 +1,17 @@ +.TH "nvme_ns_write_zeros" 9 "nvme_ns_write_zeros" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_ns_write_zeros \- Write zeros to a namespace +.SH SYNOPSIS +.B "int" nvme_ns_write_zeros +.BI "(nvme_ns_t n " "," +.BI "off_t offset " "," +.BI "size_t count " ");" +.SH ARGUMENTS +.IP "n" 12 +Namespace instance +.IP "offset" 12 +LBA offset in \fIn\fP +.IP "count" 12 +Number of sectors to be written +.SH "RETURN" +Number of sectors written diff --git a/doc/man/nvme_nss_hw_err_event.2 b/doc/man/nvme_nss_hw_err_event.2 new file mode 100644 index 0000000..a64966e --- /dev/null +++ b/doc/man/nvme_nss_hw_err_event.2 @@ -0,0 +1,23 @@ +.TH "libnvme" 9 "struct nvme_nss_hw_err_event" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_nss_hw_err_event \- +.SH SYNOPSIS +struct nvme_nss_hw_err_event { +.br +.BI " __le16 nss_hw_err_event_code;" +.br +.BI " __u8 rsvd2[2];" +.br +.BI " __u8 *add_hw_err_info;" +.br +.BI " +}; +.br + +.SH Members +.IP "nss_hw_err_event_code" 12 +NVM Subsystem Hardware Error Event Code +.IP "rsvd2" 12 +Reserved +.IP "add_hw_err_info" 12 +Additional Hardware Error Information diff --git a/doc/man/nvme_nvm_id_ns.2 b/doc/man/nvme_nvm_id_ns.2 new file mode 100644 index 0000000..13dae13 --- /dev/null +++ b/doc/man/nvme_nvm_id_ns.2 @@ -0,0 +1,31 @@ +.TH "libnvme" 9 "struct nvme_nvm_id_ns" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_nvm_id_ns \- +.SH SYNOPSIS +struct nvme_nvm_id_ns { +.br +.BI " __le64 lbstm;" +.br +.BI " __u8 pic;" +.br +.BI " __u8 rsvd9[3];" +.br +.BI " __le32 elbaf[64];" +.br +.BI " __u8 rsvd268[3828];" +.br +.BI " +}; +.br + +.SH Members +.IP "lbstm" 12 +Logical Block Storage Tag Mask +.IP "pic" 12 +Protection Information Capabilities +.IP "rsvd9" 12 +Reserved +.IP "elbaf" 12 +List of Extended LBA Format Support +.IP "rsvd268" 12 +Reserved diff --git a/doc/man/nvme_nvm_identify_ctrl.2 b/doc/man/nvme_nvm_identify_ctrl.2 new file mode 100644 index 0000000..313368a --- /dev/null +++ b/doc/man/nvme_nvm_identify_ctrl.2 @@ -0,0 +1,18 @@ +.TH "nvme_nvm_identify_ctrl" 9 "nvme_nvm_identify_ctrl" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_nvm_identify_ctrl \- Identify controller data +.SH SYNOPSIS +.B "int" nvme_nvm_identify_ctrl +.BI "(int fd " "," +.BI "struct nvme_id_ctrl_nvm *id " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "id" 12 +User space destination address to transfer the data +.SH "DESCRIPTION" +Return an identify controller data structure to the host of +processing controller. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_nvmeset_pl_status.2 b/doc/man/nvme_nvmeset_pl_status.2 new file mode 100644 index 0000000..3c224b4 --- /dev/null +++ b/doc/man/nvme_nvmeset_pl_status.2 @@ -0,0 +1,21 @@ +.TH "libnvme" 9 "enum nvme_nvmeset_pl_status" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_nvmeset_pl_status \- +.SH SYNOPSIS +enum nvme_nvmeset_pl_status { +.br +.BI " NVME_NVMSET_PL_STATUS_DISABLED" +, +.br +.br +.BI " NVME_NVMSET_PL_STATUS_DTWIN" +, +.br +.br +.BI " NVME_NVMSET_PL_STATUS_NDWIN" + +}; +.SH Constants +.IP "NVME_NVMSET_PL_STATUS_DISABLED" 12 +.IP "NVME_NVMSET_PL_STATUS_DTWIN" 12 +.IP "NVME_NVMSET_PL_STATUS_NDWIN" 12 diff --git a/doc/man/nvme_nvmset_attr.2 b/doc/man/nvme_nvmset_attr.2 new file mode 100644 index 0000000..450378c --- /dev/null +++ b/doc/man/nvme_nvmset_attr.2 @@ -0,0 +1,46 @@ +.TH "libnvme" 9 "struct nvme_nvmset_attr" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_nvmset_attr \- NVM Set Attributes Entry +.SH SYNOPSIS +struct nvme_nvmset_attr { +.br +.BI " __le16 nvmsetid;" +.br +.BI " __le16 endgid;" +.br +.BI " __u8 rsvd4[4];" +.br +.BI " __le32 rr4kt;" +.br +.BI " __le32 ows;" +.br +.BI " __u8 tnvmsetcap[16];" +.br +.BI " __u8 unvmsetcap[16];" +.br +.BI " __u8 rsvd48[80];" +.br +.BI " +}; +.br + +.SH Members +.IP "nvmsetid" 12 +NVM Set Identifier +.IP "endgid" 12 +Endurance Group Identifier +.IP "rsvd4" 12 +Reserved +.IP "rr4kt" 12 +Random 4 KiB Read Typical indicates the typical +time to complete a 4 KiB random read in 100 nanosecond units +when the NVM Set is in a Predictable Latency Mode Deterministic +Window and there is 1 outstanding command per NVM Set. +.IP "ows" 12 +Optimal Write Size +.IP "tnvmsetcap" 12 +Total NVM Set Capacity +.IP "unvmsetcap" 12 +Unallocated NVM Set Capacity +.IP "rsvd48" 12 +Reserved diff --git a/doc/man/nvme_nvmset_pl_events.2 b/doc/man/nvme_nvmset_pl_events.2 new file mode 100644 index 0000000..36fe819 --- /dev/null +++ b/doc/man/nvme_nvmset_pl_events.2 @@ -0,0 +1,31 @@ +.TH "libnvme" 9 "enum nvme_nvmset_pl_events" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_nvmset_pl_events \- +.SH SYNOPSIS +enum nvme_nvmset_pl_events { +.br +.BI " NVME_NVMSET_PL_EVENT_DTWIN_READ_WARN" +, +.br +.br +.BI " NVME_NVMSET_PL_EVENT_DTWIN_WRITE_WARN" +, +.br +.br +.BI " NVME_NVMSET_PL_EVENT_DTWIN_TIME_WARN" +, +.br +.br +.BI " NVME_NVMSET_PL_EVENT_DTWIN_EXCEEDED" +, +.br +.br +.BI " NVME_NVMSET_PL_EVENT_DTWIN_EXCURSION" + +}; +.SH Constants +.IP "NVME_NVMSET_PL_EVENT_DTWIN_READ_WARN" 12 +.IP "NVME_NVMSET_PL_EVENT_DTWIN_WRITE_WARN" 12 +.IP "NVME_NVMSET_PL_EVENT_DTWIN_TIME_WARN" 12 +.IP "NVME_NVMSET_PL_EVENT_DTWIN_EXCEEDED" 12 +.IP "NVME_NVMSET_PL_EVENT_DTWIN_EXCURSION" 12 diff --git a/doc/man/nvme_nvmset_predictable_lat_log.2 b/doc/man/nvme_nvmset_predictable_lat_log.2 new file mode 100644 index 0000000..172bdce --- /dev/null +++ b/doc/man/nvme_nvmset_predictable_lat_log.2 @@ -0,0 +1,67 @@ +.TH "libnvme" 9 "struct nvme_nvmset_predictable_lat_log" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_nvmset_predictable_lat_log \- +.SH SYNOPSIS +struct nvme_nvmset_predictable_lat_log { +.br +.BI " __u8 status;" +.br +.BI " __u8 rsvd1;" +.br +.BI " __le16 event_type;" +.br +.BI " __u8 rsvd4[28];" +.br +.BI " __le64 dtwin_rt;" +.br +.BI " __le64 dtwin_wt;" +.br +.BI " __le64 dtwin_tmax;" +.br +.BI " __le64 ndwin_tmin_hi;" +.br +.BI " __le64 ndwin_tmin_lo;" +.br +.BI " __u8 rsvd72[56];" +.br +.BI " __le64 dtwin_re;" +.br +.BI " __le64 dtwin_we;" +.br +.BI " __le64 dtwin_te;" +.br +.BI " __u8 rsvd152[360];" +.br +.BI " +}; +.br + +.SH Members +.IP "status" 12 +Status +.IP "rsvd1" 12 +Reserved +.IP "event_type" 12 +Event Type +.IP "rsvd4" 12 +Reserved +.IP "dtwin_rt" 12 +DTWIN Reads Typical +.IP "dtwin_wt" 12 +DTWIN Writes Typical +.IP "dtwin_tmax" 12 +DTWIN Time Maximum +.IP "ndwin_tmin_hi" 12 +NDWIN Time Minimum High +.IP "ndwin_tmin_lo" 12 +NDWIN Time Minimum Low +.IP "rsvd72" 12 +Reserved +.IP "dtwin_re" 12 +DTWIN Reads Estimate +.IP "dtwin_we" 12 +DTWIN Writes Estimate +.IP "dtwin_te" 12 +DTWIN Time Estimate +.IP "rsvd152" 12 +Reserved diff --git a/doc/man/nvme_open.2 b/doc/man/nvme_open.2 new file mode 100644 index 0000000..5d7e7d0 --- /dev/null +++ b/doc/man/nvme_open.2 @@ -0,0 +1,15 @@ +.TH "nvme_open" 9 "nvme_open" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_open \- Open an nvme controller or namespace device +.SH SYNOPSIS +.B "int" nvme_open +.BI "(const char *name " ");" +.SH ARGUMENTS +.IP "name" 12 +The basename of the device to open +.SH "DESCRIPTION" +This will look for the handle in /dev/ and validate the name and filetype +match linux conventions. +.SH "RETURN" +A file descriptor for the device on a successful open, or -1 with +errno set otherwise. diff --git a/doc/man/nvme_passthru_cmd.2 b/doc/man/nvme_passthru_cmd.2 new file mode 100644 index 0000000..dbe721a --- /dev/null +++ b/doc/man/nvme_passthru_cmd.2 @@ -0,0 +1,83 @@ +.TH "libnvme" 9 "struct nvme_passthru_cmd" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_passthru_cmd \- nvme passthrough command structure +.SH SYNOPSIS +struct nvme_passthru_cmd { +.br +.BI " __u8 opcode;" +.br +.BI " __u8 flags;" +.br +.BI " __u16 rsvd1;" +.br +.BI " __u32 nsid;" +.br +.BI " __u32 cdw2;" +.br +.BI " __u32 cdw3;" +.br +.BI " __u64 metadata;" +.br +.BI " __u64 addr;" +.br +.BI " __u32 metadata_len;" +.br +.BI " __u32 data_len;" +.br +.BI " __u32 cdw10;" +.br +.BI " __u32 cdw11;" +.br +.BI " __u32 cdw12;" +.br +.BI " __u32 cdw13;" +.br +.BI " __u32 cdw14;" +.br +.BI " __u32 cdw15;" +.br +.BI " __u32 timeout_ms;" +.br +.BI " __u32 result;" +.br +.BI " +}; +.br + +.SH Members +.IP "opcode" 12 +Operation code, see \fIenum nvme_io_opcodes\fP and \fIenum nvme_admin_opcodes\fP +.IP "flags" 12 +Not supported: intended for command flags (eg: SGL, FUSE) +.IP "rsvd1" 12 +Reserved for future use +.IP "nsid" 12 +Namespace Identifier, or Fabrics type +.IP "cdw2" 12 +Command Dword 2 (no spec defined use) +.IP "cdw3" 12 +Command Dword 3 (no spec defined use) +.IP "metadata" 12 +User space address to metadata buffer (NULL if not used) +.IP "addr" 12 +User space address to data buffer (NULL if not used) +.IP "metadata_len" 12 +Metadata buffer transfer length +.IP "data_len" 12 +Data buffer transfer length +.IP "cdw10" 12 +Command Dword 10 (command specific) +.IP "cdw11" 12 +Command Dword 11 (command specific) +.IP "cdw12" 12 +Command Dword 12 (command specific) +.IP "cdw13" 12 +Command Dword 13 (command specific) +.IP "cdw14" 12 +Command Dword 14 (command specific) +.IP "cdw15" 12 +Command Dword 15 (command specific) +.IP "timeout_ms" 12 +If non-zero, overrides system default timeout in milliseconds +.IP "result" 12 +Set on completion to the command's CQE DWORD 0 controller response diff --git a/doc/man/nvme_path_get_ana_state.2 b/doc/man/nvme_path_get_ana_state.2 new file mode 100644 index 0000000..aea9250 --- /dev/null +++ b/doc/man/nvme_path_get_ana_state.2 @@ -0,0 +1,11 @@ +.TH "nvme_path_get_ana_state" 9 "nvme_path_get_ana_state" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_path_get_ana_state \- ANA state of an nvme_path_t object +.SH SYNOPSIS +.B "const char *" nvme_path_get_ana_state +.BI "(nvme_path_t p " ");" +.SH ARGUMENTS +.IP "p" 12 +\fInvme_path_t\fP object +.SH "RETURN" +ANA (Asynchronous Namespace Access) state of \fIp\fP diff --git a/doc/man/nvme_path_get_ctrl.2 b/doc/man/nvme_path_get_ctrl.2 new file mode 100644 index 0000000..eb5a046 --- /dev/null +++ b/doc/man/nvme_path_get_ctrl.2 @@ -0,0 +1,11 @@ +.TH "nvme_path_get_ctrl" 9 "nvme_path_get_ctrl" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_path_get_ctrl \- Parent controller of an nvme_path_t object +.SH SYNOPSIS +.B "nvme_ctrl_t" nvme_path_get_ctrl +.BI "(nvme_path_t p " ");" +.SH ARGUMENTS +.IP "p" 12 +\fInvme_path_t\fP object +.SH "RETURN" +Parent controller if present diff --git a/doc/man/nvme_path_get_name.2 b/doc/man/nvme_path_get_name.2 new file mode 100644 index 0000000..5d78c61 --- /dev/null +++ b/doc/man/nvme_path_get_name.2 @@ -0,0 +1,11 @@ +.TH "nvme_path_get_name" 9 "nvme_path_get_name" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_path_get_name \- sysfs name of an &nvme_path_t object +.SH SYNOPSIS +.B "const char *" nvme_path_get_name +.BI "(nvme_path_t p " ");" +.SH ARGUMENTS +.IP "p" 12 +\fInvme_path_t\fP object +.SH "RETURN" +sysfs name of \fIp\fP diff --git a/doc/man/nvme_path_get_ns.2 b/doc/man/nvme_path_get_ns.2 new file mode 100644 index 0000000..6fb4450 --- /dev/null +++ b/doc/man/nvme_path_get_ns.2 @@ -0,0 +1,11 @@ +.TH "nvme_path_get_ns" 9 "nvme_path_get_ns" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_path_get_ns \- Parent namespace of an nvme_path_t object +.SH SYNOPSIS +.B "nvme_ns_t" nvme_path_get_ns +.BI "(nvme_path_t p " ");" +.SH ARGUMENTS +.IP "p" 12 +\fInvme_path_t\fP object +.SH "RETURN" +Parent namespace if present diff --git a/doc/man/nvme_path_get_sysfs_dir.2 b/doc/man/nvme_path_get_sysfs_dir.2 new file mode 100644 index 0000000..f14b537 --- /dev/null +++ b/doc/man/nvme_path_get_sysfs_dir.2 @@ -0,0 +1,11 @@ +.TH "nvme_path_get_sysfs_dir" 9 "nvme_path_get_sysfs_dir" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_path_get_sysfs_dir \- sysfs directory of an nvme_path_t object +.SH SYNOPSIS +.B "const char *" nvme_path_get_sysfs_dir +.BI "(nvme_path_t p " ");" +.SH ARGUMENTS +.IP "p" 12 +\fInvme_path_t\fP object +.SH "RETURN" +sysfs directory of \fIp\fP diff --git a/doc/man/nvme_paths_filter.2 b/doc/man/nvme_paths_filter.2 new file mode 100644 index 0000000..d2d2955 --- /dev/null +++ b/doc/man/nvme_paths_filter.2 @@ -0,0 +1,11 @@ +.TH "nvme_paths_filter" 9 "nvme_paths_filter" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_paths_filter \- Filter for paths +.SH SYNOPSIS +.B "int" nvme_paths_filter +.BI "(const struct dirent *d " ");" +.SH ARGUMENTS +.IP "d" 12 +dirent to check +.SH "RETURN" +1 if \fId\fP matches, 0 otherwise diff --git a/doc/man/nvme_persistent_event_entry.2 b/doc/man/nvme_persistent_event_entry.2 new file mode 100644 index 0000000..0e19ab9 --- /dev/null +++ b/doc/man/nvme_persistent_event_entry.2 @@ -0,0 +1,51 @@ +.TH "libnvme" 9 "struct nvme_persistent_event_entry" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_persistent_event_entry \- +.SH SYNOPSIS +struct nvme_persistent_event_entry { +.br +.BI " __u8 etype;" +.br +.BI " __u8 etype_rev;" +.br +.BI " __u8 ehl;" +.br +.BI " __u8 ehai;" +.br +.BI " __le16 cntlid;" +.br +.BI " __le64 ets;" +.br +.BI " __le16 pelpid;" +.br +.BI " __u8 rsvd16[4];" +.br +.BI " __le16 vsil;" +.br +.BI " __le16 el;" +.br +.BI " +}; +.br + +.SH Members +.IP "etype" 12 +Event Type +.IP "etype_rev" 12 +Event Type Revision +.IP "ehl" 12 +Event Header Length +.IP "ehai" 12 +Event Header Additional Info +.IP "cntlid" 12 +Controller Identifier +.IP "ets" 12 +Event Timestamp +.IP "pelpid" 12 +Port Identifier +.IP "rsvd16" 12 +Reserved +.IP "vsil" 12 +Vendor Specific Information Length +.IP "el" 12 +Event Length diff --git a/doc/man/nvme_persistent_event_log.2 b/doc/man/nvme_persistent_event_log.2 new file mode 100644 index 0000000..466b333 --- /dev/null +++ b/doc/man/nvme_persistent_event_log.2 @@ -0,0 +1,87 @@ +.TH "libnvme" 9 "struct nvme_persistent_event_log" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_persistent_event_log \- +.SH SYNOPSIS +struct nvme_persistent_event_log { +.br +.BI " __u8 lid;" +.br +.BI " __u8 rsvd1[3];" +.br +.BI " __le32 tnev;" +.br +.BI " __le64 tll;" +.br +.BI " __u8 rv;" +.br +.BI " __u8 rsvd17;" +.br +.BI " __le16 lhl;" +.br +.BI " __le64 ts;" +.br +.BI " __u8 poh[16];" +.br +.BI " __le64 pcc;" +.br +.BI " __le16 vid;" +.br +.BI " __le16 ssvid;" +.br +.BI " char sn[20];" +.br +.BI " char mn[40];" +.br +.BI " char subnqn[NVME_NQN_LENGTH];" +.br +.BI " __le16 gen_number;" +.br +.BI " __le32 rci;" +.br +.BI " __u8 rsvd378[102];" +.br +.BI " __u8 seb[32];" +.br +.BI " +}; +.br + +.SH Members +.IP "lid" 12 +Log Identifier +.IP "rsvd1" 12 +Reserved +.IP "tnev" 12 +Total Number of Events +.IP "tll" 12 +Total Log Length +.IP "rv" 12 +Log Revision +.IP "rsvd17" 12 +Reserved +.IP "lhl" 12 +Log Header Length +.IP "ts" 12 +Timestamp +.IP "poh" 12 +Power on Hours +.IP "pcc" 12 +Power Cycle Count +.IP "vid" 12 +PCI Vendor ID +.IP "ssvid" 12 +PCI Subsystem Vendor ID +.IP "sn" 12 +Serial Number +.IP "mn" 12 +Model Number +.IP "subnqn" 12 +NVM Subsystem NVMe Qualified Name +.IP "gen_number" 12 +Generation Number +.IP "rci" 12 +Reporting Context Information +.IP "rsvd378" 12 +Reserved +.IP "seb" 12 +Supported Events Bitmap diff --git a/doc/man/nvme_persistent_event_types.2 b/doc/man/nvme_persistent_event_types.2 new file mode 100644 index 0000000..42900f8 --- /dev/null +++ b/doc/man/nvme_persistent_event_types.2 @@ -0,0 +1,71 @@ +.TH "libnvme" 9 "enum nvme_persistent_event_types" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_persistent_event_types \- +.SH SYNOPSIS +enum nvme_persistent_event_types { +.br +.BI " NVME_PEL_SMART_HEALTH_EVENT" +, +.br +.br +.BI " NVME_PEL_FW_COMMIT_EVENT" +, +.br +.br +.BI " NVME_PEL_TIMESTAMP_EVENT" +, +.br +.br +.BI " NVME_PEL_POWER_ON_RESET_EVENT" +, +.br +.br +.BI " NVME_PEL_NSS_HW_ERROR_EVENT" +, +.br +.br +.BI " NVME_PEL_CHANGE_NS_EVENT" +, +.br +.br +.BI " NVME_PEL_FORMAT_START_EVENT" +, +.br +.br +.BI " NVME_PEL_FORMAT_COMPLETION_EVENT" +, +.br +.br +.BI " NVME_PEL_SANITIZE_START_EVENT" +, +.br +.br +.BI " NVME_PEL_SANITIZE_COMPLETION_EVENT" +, +.br +.br +.BI " NVME_PEL_SET_FEATURE_EVENT" +, +.br +.br +.BI " NVME_PEL_TELEMETRY_CRT" +, +.br +.br +.BI " NVME_PEL_THERMAL_EXCURSION_EVENT" + +}; +.SH Constants +.IP "NVME_PEL_SMART_HEALTH_EVENT" 12 +.IP "NVME_PEL_FW_COMMIT_EVENT" 12 +.IP "NVME_PEL_TIMESTAMP_EVENT" 12 +.IP "NVME_PEL_POWER_ON_RESET_EVENT" 12 +.IP "NVME_PEL_NSS_HW_ERROR_EVENT" 12 +.IP "NVME_PEL_CHANGE_NS_EVENT" 12 +.IP "NVME_PEL_FORMAT_START_EVENT" 12 +.IP "NVME_PEL_FORMAT_COMPLETION_EVENT" 12 +.IP "NVME_PEL_SANITIZE_START_EVENT" 12 +.IP "NVME_PEL_SANITIZE_COMPLETION_EVENT" 12 +.IP "NVME_PEL_SET_FEATURE_EVENT" 12 +.IP "NVME_PEL_TELEMETRY_CRT" 12 +.IP "NVME_PEL_THERMAL_EXCURSION_EVENT" 12 diff --git a/doc/man/nvme_pevent_log_action.2 b/doc/man/nvme_pevent_log_action.2 new file mode 100644 index 0000000..d0e500b --- /dev/null +++ b/doc/man/nvme_pevent_log_action.2 @@ -0,0 +1,24 @@ +.TH "libnvme" 9 "enum nvme_pevent_log_action" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_pevent_log_action \- +.SH SYNOPSIS +enum nvme_pevent_log_action { +.br +.BI " NVME_PEVENT_LOG_READ" +, +.br +.br +.BI " NVME_PEVENT_LOG_EST_CTX_AND_READ" +, +.br +.br +.BI " NVME_PEVENT_LOG_RELEASE_CTX" + +}; +.SH Constants +.IP "NVME_PEVENT_LOG_READ" 12 +Read Log Data +.IP "NVME_PEVENT_LOG_EST_CTX_AND_READ" 12 +Establish Context and Read Log Data +.IP "NVME_PEVENT_LOG_RELEASE_CTX" 12 +Release Context diff --git a/doc/man/nvme_plm_config.2 b/doc/man/nvme_plm_config.2 new file mode 100644 index 0000000..098aec6 --- /dev/null +++ b/doc/man/nvme_plm_config.2 @@ -0,0 +1,35 @@ +.TH "libnvme" 9 "struct nvme_plm_config" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_plm_config \- +.SH SYNOPSIS +struct nvme_plm_config { +.br +.BI " __le16 ee;" +.br +.BI " __u8 rsvd2[30];" +.br +.BI " __le64 dtwinrt;" +.br +.BI " __le64 dtwinwt;" +.br +.BI " __le64 dtwintt;" +.br +.BI " __u8 rsvd56[456];" +.br +.BI " +}; +.br + +.SH Members +.IP "ee" 12 +Enable Event +.IP "rsvd2" 12 +Reserved +.IP "dtwinrt" 12 +DTWIN Reads Threshold +.IP "dtwinwt" 12 +DTWIN Writes Threshold +.IP "dtwintt" 12 +DTWIN Time Threshold +.IP "rsvd56" 12 +Reserved diff --git a/doc/man/nvme_pmr_size.2 b/doc/man/nvme_pmr_size.2 new file mode 100644 index 0000000..07e7906 --- /dev/null +++ b/doc/man/nvme_pmr_size.2 @@ -0,0 +1,11 @@ +.TH "nvme_pmr_size" 9 "nvme_pmr_size" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_pmr_size \- Calculate size of persistent memory region elasticity buffer +.SH SYNOPSIS +.B "__u64" nvme_pmr_size +.BI "(__u32 pmrebs " ");" +.SH ARGUMENTS +.IP "pmrebs" 12 +Value from controller register NVME_REG_PMREBS +.SH "DESCRIPTION" +Returns size of controller persistent memory buffer in bytes diff --git a/doc/man/nvme_pmr_throughput.2 b/doc/man/nvme_pmr_throughput.2 new file mode 100644 index 0000000..5a1d88b --- /dev/null +++ b/doc/man/nvme_pmr_throughput.2 @@ -0,0 +1,11 @@ +.TH "nvme_pmr_throughput" 9 "nvme_pmr_throughput" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_pmr_throughput \- Calculate throughput of persistent memory buffer +.SH SYNOPSIS +.B "__u64" nvme_pmr_throughput +.BI "(__u32 pmrswtp " ");" +.SH ARGUMENTS +.IP "pmrswtp" 12 +Value from controller register NVME_REG_PMRSWTP +.SH "DESCRIPTION" +Returns throughput of controller persistent memory buffer in bytes/second diff --git a/doc/man/nvme_power_on_reset_info_list.2 b/doc/man/nvme_power_on_reset_info_list.2 new file mode 100644 index 0000000..2e08e42 --- /dev/null +++ b/doc/man/nvme_power_on_reset_info_list.2 @@ -0,0 +1,39 @@ +.TH "libnvme" 9 "struct nvme_power_on_reset_info_list" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_power_on_reset_info_list \- +.SH SYNOPSIS +struct nvme_power_on_reset_info_list { +.br +.BI " __le16 cid;" +.br +.BI " __u8 fw_act;" +.br +.BI " __u8 op_in_prog;" +.br +.BI " __u8 rsvd4[12];" +.br +.BI " __le32 ctrl_power_cycle;" +.br +.BI " __le64 power_on_ml_seconds;" +.br +.BI " __le64 ctrl_time_stamp;" +.br +.BI " +}; +.br + +.SH Members +.IP "cid" 12 +Controller ID +.IP "fw_act" 12 +Firmware Activation +.IP "op_in_prog" 12 +Operation in Progress +.IP "rsvd4" 12 +Reserved +.IP "ctrl_power_cycle" 12 +Controller Power Cycle +.IP "power_on_ml_seconds" 12 +Power on milliseconds +.IP "ctrl_time_stamp" 12 +Controller Timestamp diff --git a/doc/man/nvme_primary_ctrl_cap.2 b/doc/man/nvme_primary_ctrl_cap.2 new file mode 100644 index 0000000..05aa41d --- /dev/null +++ b/doc/man/nvme_primary_ctrl_cap.2 @@ -0,0 +1,83 @@ +.TH "libnvme" 9 "struct nvme_primary_ctrl_cap" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_primary_ctrl_cap \- +.SH SYNOPSIS +struct nvme_primary_ctrl_cap { +.br +.BI " __le16 cntlid;" +.br +.BI " __le16 portid;" +.br +.BI " __u8 crt;" +.br +.BI " __u8 rsvd5[27];" +.br +.BI " __le32 vqfrt;" +.br +.BI " __le32 vqrfa;" +.br +.BI " __le16 vqrfap;" +.br +.BI " __le16 vqprt;" +.br +.BI " __le16 vqfrsm;" +.br +.BI " __le16 vqgran;" +.br +.BI " __u8 rsvd48[16];" +.br +.BI " __le32 vifrt;" +.br +.BI " __le32 virfa;" +.br +.BI " __le16 virfap;" +.br +.BI " __le16 viprt;" +.br +.BI " __le16 vifrsm;" +.br +.BI " __le16 vigran;" +.br +.BI " __u8 rsvd80[4016];" +.br +.BI " +}; +.br + +.SH Members +.IP "cntlid" 12 +Controller Identifier +.IP "portid" 12 +Port Identifier +.IP "crt" 12 +Controller Resource Types +.IP "rsvd5" 12 +reserved +.IP "vqfrt" 12 +VQ Resources Flexible Total +.IP "vqrfa" 12 +VQ Resources Flexible Assigned +.IP "vqrfap" 12 +VQ Resources Flexible Allocated to Primary +.IP "vqprt" 12 +VQ Resources Private Total +.IP "vqfrsm" 12 +VQ Resources Flexible Secondary Maximum +.IP "vqgran" 12 +VQ Flexible Resource Preferred Granularity +.IP "rsvd48" 12 +reserved +.IP "vifrt" 12 +VI Resources Flexible Total +.IP "virfa" 12 +VI Resources Flexible Assigned +.IP "virfap" 12 +VI Resources Flexible Allocated to Primary +.IP "viprt" 12 +VI Resources Private Total +.IP "vifrsm" 12 +VI Resources Flexible Secondary Maximum +.IP "vigran" 12 +VI Flexible Resource Preferred Granularity +.IP "rsvd80" 12 +reserved diff --git a/doc/man/nvme_psd_flags.2 b/doc/man/nvme_psd_flags.2 new file mode 100644 index 0000000..655a4db --- /dev/null +++ b/doc/man/nvme_psd_flags.2 @@ -0,0 +1,26 @@ +.TH "libnvme" 9 "enum nvme_psd_flags" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_psd_flags \- Possible flag values in nvme power state descriptor +.SH SYNOPSIS +enum nvme_psd_flags { +.br +.BI " NVME_PSD_FLAGS_MXPS" +, +.br +.br +.BI " NVME_PSD_FLAGS_NOPS" + +}; +.SH Constants +.IP "NVME_PSD_FLAGS_MXPS" 12 +Indicates the scale for the Maximum Power +field. If this bit is cleared, then the scale of the +Maximum Power field is in 0.01 Watts. If this bit is +set, then the scale of the Maximum Power field is in +0.0001 Watts. +.IP "NVME_PSD_FLAGS_NOPS" 12 +Indicates whether the controller processes I/O +commands in this power state. If this bit is cleared, +then the controller processes I/O commands in this +power state. If this bit is set, then the controller +does not process I/O commands in this power state. diff --git a/doc/man/nvme_psd_power_scale.2 b/doc/man/nvme_psd_power_scale.2 new file mode 100644 index 0000000..974c60e --- /dev/null +++ b/doc/man/nvme_psd_power_scale.2 @@ -0,0 +1,9 @@ +.TH "nvme_psd_power_scale" 9 "nvme_psd_power_scale" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_psd_power_scale \- power scale occupies the upper 3 bits +.SH SYNOPSIS +.B "unsigned int" nvme_psd_power_scale +.BI "(__u8 ps " ");" +.SH ARGUMENTS +.IP "ps" 12 +power scale value diff --git a/doc/man/nvme_psd_ps.2 b/doc/man/nvme_psd_ps.2 new file mode 100644 index 0000000..bd5e403 --- /dev/null +++ b/doc/man/nvme_psd_ps.2 @@ -0,0 +1,18 @@ +.TH "libnvme" 9 "enum nvme_psd_ps" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_psd_ps \- Known values for &struct nvme_psd %ips and %aps. Use with nvme_psd_power_scale() to extract the power scale field to match this enum. +.SH SYNOPSIS +enum nvme_psd_ps { +.br +.BI " NVME_PSD_PS_100_MICRO_WATT" +, +.br +.br +.BI " NVME_PSD_PS_10_MILLI_WATT" + +}; +.SH Constants +.IP "NVME_PSD_PS_100_MICRO_WATT" 12 +0.0001 watt scale +.IP "NVME_PSD_PS_10_MILLI_WATT" 12 +0.01 watt scale diff --git a/doc/man/nvme_psd_workload.2 b/doc/man/nvme_psd_workload.2 new file mode 100644 index 0000000..2e2fe26 --- /dev/null +++ b/doc/man/nvme_psd_workload.2 @@ -0,0 +1,29 @@ +.TH "libnvme" 9 "enum nvme_psd_workload" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_psd_workload \- Specifies a workload hint in the Power Management Feature (see &struct nvme_psd.apw) to inform the NVM subsystem or indicate the conditions for the active power level. +.SH SYNOPSIS +enum nvme_psd_workload { +.br +.BI " NVME_PSD_WORKLOAD_1" +, +.br +.br +.BI " NVME_PSD_WORKLOAD_2" + +}; +.SH Constants +.IP "NVME_PSD_WORKLOAD_1" 12 +Extended Idle Period with a Burst of Random Write +consists of five minutes of idle followed by +thirty-two random write commands of size 1 MiB +submitted to a single controller while all other +controllers in the NVM subsystem are idle, and then +thirty (30) seconds of idle. +.IP "NVME_PSD_WORKLOAD_2" 12 +Heavy Sequential Writes consists of 80,000 +sequential write commands of size 128 KiB submitted to +a single controller while all other controllers in the +NVM subsystem are idle. The submission queue(s) +should be sufficiently large allowing the host to +ensure there are multiple commands pending at all +times during the workload. diff --git a/doc/man/nvme_read.2 b/doc/man/nvme_read.2 new file mode 100644 index 0000000..7e25fe3 --- /dev/null +++ b/doc/man/nvme_read.2 @@ -0,0 +1,12 @@ +.TH "nvme_read" 9 "nvme_read" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_read \- Submit an nvme user read command +.SH SYNOPSIS +.B "int" nvme_read +.BI "(struct nvme_io_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_io_args\fP argument structure +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_read_config.2 b/doc/man/nvme_read_config.2 new file mode 100644 index 0000000..3f5867f --- /dev/null +++ b/doc/man/nvme_read_config.2 @@ -0,0 +1,17 @@ +.TH "nvme_read_config" 9 "nvme_read_config" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_read_config \- Read NVMe JSON configuration file +.SH SYNOPSIS +.B "int" nvme_read_config +.BI "(nvme_root_t r " "," +.BI "const char *config_file " ");" +.SH ARGUMENTS +.IP "r" 12 +nvme_root_t object +.IP "config_file" 12 +JSON configuration file +.SH "DESCRIPTION" +Read in the contents of \fIconfig_file\fP and merge them with +the elements in \fIr\fP. +.SH "RETURN" +0 on success, -1 on failure with errno set. diff --git a/doc/man/nvme_refresh_topology.2 b/doc/man/nvme_refresh_topology.2 new file mode 100644 index 0000000..625310c --- /dev/null +++ b/doc/man/nvme_refresh_topology.2 @@ -0,0 +1,11 @@ +.TH "nvme_refresh_topology" 9 "nvme_refresh_topology" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_refresh_topology \- Refresh nvme_root_t object contents +.SH SYNOPSIS +.B "void" nvme_refresh_topology +.BI "(nvme_root_t r " ");" +.SH ARGUMENTS +.IP "r" 12 +nvme_root_t object +.SH "DESCRIPTION" +Removes all elements in \fIr\fP and rescans the existing topology. diff --git a/doc/man/nvme_register_offsets.2 b/doc/man/nvme_register_offsets.2 new file mode 100644 index 0000000..c10bed5 --- /dev/null +++ b/doc/man/nvme_register_offsets.2 @@ -0,0 +1,150 @@ +.TH "libnvme" 9 "enum nvme_register_offsets" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_register_offsets \- controller registers for all transports. This is the layout of BAR0/1 for PCIe, and properties for fabrics. +.SH SYNOPSIS +enum nvme_register_offsets { +.br +.BI " NVME_REG_CAP" +, +.br +.br +.BI " NVME_REG_VS" +, +.br +.br +.BI " NVME_REG_INTMS" +, +.br +.br +.BI " NVME_REG_INTMC" +, +.br +.br +.BI " NVME_REG_CC" +, +.br +.br +.BI " NVME_REG_CSTS" +, +.br +.br +.BI " NVME_REG_NSSR" +, +.br +.br +.BI " NVME_REG_AQA" +, +.br +.br +.BI " NVME_REG_ASQ" +, +.br +.br +.BI " NVME_REG_ACQ" +, +.br +.br +.BI " NVME_REG_CMBLOC" +, +.br +.br +.BI " NVME_REG_CMBSZ" +, +.br +.br +.BI " NVME_REG_BPINFO" +, +.br +.br +.BI " NVME_REG_BPRSEL" +, +.br +.br +.BI " NVME_REG_BPMBL" +, +.br +.br +.BI " NVME_REG_CMBMSC" +, +.br +.br +.BI " NVME_REG_CMBSTS" +, +.br +.br +.BI " NVME_REG_PMRCAP" +, +.br +.br +.BI " NVME_REG_PMRCTL" +, +.br +.br +.BI " NVME_REG_PMRSTS" +, +.br +.br +.BI " NVME_REG_PMREBS" +, +.br +.br +.BI " NVME_REG_PMRSWTP" +, +.br +.br +.BI " NVME_REG_PMRMSCL" +, +.br +.br +.BI " NVME_REG_PMRMSCU" + +}; +.SH Constants +.IP "NVME_REG_CAP" 12 +Controller Capabilities +.IP "NVME_REG_VS" 12 +Version +.IP "NVME_REG_INTMS" 12 +Interrupt Mask Set +.IP "NVME_REG_INTMC" 12 +Interrupt Mask Clear +.IP "NVME_REG_CC" 12 +Controller Configuration +.IP "NVME_REG_CSTS" 12 +Controller Status +.IP "NVME_REG_NSSR" 12 +NVM Subsystem Reset +.IP "NVME_REG_AQA" 12 +Admin Queue Attributes +.IP "NVME_REG_ASQ" 12 +Admin SQ Base Address +.IP "NVME_REG_ACQ" 12 +Admin CQ Base Address +.IP "NVME_REG_CMBLOC" 12 +Controller Memory Buffer Location +.IP "NVME_REG_CMBSZ" 12 +Controller Memory Buffer Size +.IP "NVME_REG_BPINFO" 12 +Boot Partition Information +.IP "NVME_REG_BPRSEL" 12 +Boot Partition Read Select +.IP "NVME_REG_BPMBL" 12 +Boot Partition Memory Buffer Location +.IP "NVME_REG_CMBMSC" 12 +Controller Memory Buffer Memory Space Control +.IP "NVME_REG_CMBSTS" 12 +Controller Memory Buffer Status +.IP "NVME_REG_PMRCAP" 12 +Persistent Memory Capabilities +.IP "NVME_REG_PMRCTL" 12 +Persistent Memory Region Control +.IP "NVME_REG_PMRSTS" 12 +Persistent Memory Region Status +.IP "NVME_REG_PMREBS" 12 +Persistent Memory Region Elasticity Buffer Size +.IP "NVME_REG_PMRSWTP" 12 +Memory Region Sustained Write Throughput +.IP "NVME_REG_PMRMSCL" 12 +Persistent Memory Region Controller Memory Space Control Lower +.IP "NVME_REG_PMRMSCU" 12 +Persistent Memory Region Controller Memory Space Control Upper diff --git a/doc/man/nvme_registered_ctrl.2 b/doc/man/nvme_registered_ctrl.2 new file mode 100644 index 0000000..b66824e --- /dev/null +++ b/doc/man/nvme_registered_ctrl.2 @@ -0,0 +1,31 @@ +.TH "libnvme" 9 "struct nvme_registered_ctrl" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_registered_ctrl \- +.SH SYNOPSIS +struct nvme_registered_ctrl { +.br +.BI " __le16 cntlid;" +.br +.BI " __u8 rcsts;" +.br +.BI " __u8 rsvd3[5];" +.br +.BI " __le64 hostid;" +.br +.BI " __le64 rkey;" +.br +.BI " +}; +.br + +.SH Members +.IP "cntlid" 12 +Controller ID +.IP "rcsts" 12 +Reservation Status +.IP "rsvd3" 12 +Reserved +.IP "hostid" 12 +Host Identifier +.IP "rkey" 12 +Reservation Key diff --git a/doc/man/nvme_registered_ctrl_ext.2 b/doc/man/nvme_registered_ctrl_ext.2 new file mode 100644 index 0000000..04e0da2 --- /dev/null +++ b/doc/man/nvme_registered_ctrl_ext.2 @@ -0,0 +1,35 @@ +.TH "libnvme" 9 "struct nvme_registered_ctrl_ext" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_registered_ctrl_ext \- +.SH SYNOPSIS +struct nvme_registered_ctrl_ext { +.br +.BI " __le16 cntlid;" +.br +.BI " __u8 rcsts;" +.br +.BI " __u8 rsvd3[5];" +.br +.BI " __le64 rkey;" +.br +.BI " __u8 hostid[16];" +.br +.BI " __u8 rsvd32[32];" +.br +.BI " +}; +.br + +.SH Members +.IP "cntlid" 12 +Controller ID +.IP "rcsts" 12 +Reservation Status +.IP "rsvd3" 12 +Reserved +.IP "rkey" 12 +Reservation Key +.IP "hostid" 12 +Host Identifier +.IP "rsvd32" 12 +Reserved diff --git a/doc/man/nvme_rescan_ctrl.2 b/doc/man/nvme_rescan_ctrl.2 new file mode 100644 index 0000000..af1c791 --- /dev/null +++ b/doc/man/nvme_rescan_ctrl.2 @@ -0,0 +1,9 @@ +.TH "nvme_rescan_ctrl" 9 "nvme_rescan_ctrl" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_rescan_ctrl \- Rescan an existing controller +.SH SYNOPSIS +.B "void" nvme_rescan_ctrl +.BI "(nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance diff --git a/doc/man/nvme_resv_acquire.2 b/doc/man/nvme_resv_acquire.2 new file mode 100644 index 0000000..2a66281 --- /dev/null +++ b/doc/man/nvme_resv_acquire.2 @@ -0,0 +1,16 @@ +.TH "nvme_resv_acquire" 9 "nvme_resv_acquire" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_resv_acquire \- Send an nvme reservation acquire +.SH SYNOPSIS +.B "int" nvme_resv_acquire +.BI "(struct nvme_resv_acquire_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_resv_acquire\fP argument structure +.SH "DESCRIPTION" +The Reservation Acquire command acquires a reservation on a namespace, +preempt a reservation held on a namespace, and abort a reservation held on a +namespace. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_resv_acquire_args.2 b/doc/man/nvme_resv_acquire_args.2 new file mode 100644 index 0000000..bbbda30 --- /dev/null +++ b/doc/man/nvme_resv_acquire_args.2 @@ -0,0 +1,52 @@ +.TH "libnvme" 9 "struct nvme_resv_acquire_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_resv_acquire_args \- Arguments for the NVMe Reservation Acquire Comand +.SH SYNOPSIS +struct nvme_resv_acquire_args { +.br +.BI " __u64 crkey;" +.br +.BI " __u64 nrkey;" +.br +.BI " __u32 *result;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u32 nsid;" +.br +.BI " enum nvme_resv_rtype rtype;" +.br +.BI " enum nvme_resv_racqa racqa;" +.br +.BI " bool iekey;" +.br +.BI " +}; +.br + +.SH Members +.IP "crkey" 12 +The current reservation key associated with the host +.IP "nrkey" 12 +The reservation key to be unregistered from the namespace if +the action is preempt +.IP "result" 12 +The command completion result from CQE dword0 +.IP "args_size" 12 +Size of \fIstruct nvme_resv_acquire_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "nsid" 12 +Namespace identifier +.IP "rtype" 12 +The type of reservation to be create, see \fIenum nvme_resv_rtype\fP +.IP "racqa" 12 +The action that is performed by the command, see \fIenum nvme_resv_racqa\fP +.IP "iekey" 12 +Set to ignore the existing key diff --git a/doc/man/nvme_resv_cptpl.2 b/doc/man/nvme_resv_cptpl.2 new file mode 100644 index 0000000..e59177a --- /dev/null +++ b/doc/man/nvme_resv_cptpl.2 @@ -0,0 +1,26 @@ +.TH "libnvme" 9 "enum nvme_resv_cptpl" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_resv_cptpl \- +.SH SYNOPSIS +enum nvme_resv_cptpl { +.br +.BI " NVME_RESERVATION_CPTPL_NO_CHANGE" +, +.br +.br +.BI " NVME_RESERVATION_CPTPL_CLEAR" +, +.br +.br +.BI " NVME_RESERVATION_CPTPL_PERSIST" + +}; +.SH Constants +.IP "NVME_RESERVATION_CPTPL_NO_CHANGE" 12 +No change to PTPL state +.IP "NVME_RESERVATION_CPTPL_CLEAR" 12 +Reservations are released and +registrants are cleared on a power on +.IP "NVME_RESERVATION_CPTPL_PERSIST" 12 +Reservations and registrants persist +across a power loss diff --git a/doc/man/nvme_resv_notification_log.2 b/doc/man/nvme_resv_notification_log.2 new file mode 100644 index 0000000..d1e2df8 --- /dev/null +++ b/doc/man/nvme_resv_notification_log.2 @@ -0,0 +1,35 @@ +.TH "libnvme" 9 "struct nvme_resv_notification_log" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_resv_notification_log \- +.SH SYNOPSIS +struct nvme_resv_notification_log { +.br +.BI " __le64 lpc;" +.br +.BI " __u8 rnlpt;" +.br +.BI " __u8 nalp;" +.br +.BI " __u8 rsvd9[2];" +.br +.BI " __le32 nsid;" +.br +.BI " __u8 rsvd16[48];" +.br +.BI " +}; +.br + +.SH Members +.IP "lpc" 12 +Log Page Count +.IP "rnlpt" 12 +See \fIenum nvme_resv_notify_rnlpt\fP. +.IP "nalp" 12 +Number of Available Log Pages +.IP "rsvd9" 12 +Reserved +.IP "nsid" 12 +Namespace ID +.IP "rsvd16" 12 +Reserved diff --git a/doc/man/nvme_resv_notify_rnlpt.2 b/doc/man/nvme_resv_notify_rnlpt.2 new file mode 100644 index 0000000..26d54c5 --- /dev/null +++ b/doc/man/nvme_resv_notify_rnlpt.2 @@ -0,0 +1,26 @@ +.TH "libnvme" 9 "enum nvme_resv_notify_rnlpt" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_resv_notify_rnlpt \- +.SH SYNOPSIS +enum nvme_resv_notify_rnlpt { +.br +.BI " NVME_RESV_NOTIFY_RNLPT_EMPTY" +, +.br +.br +.BI " NVME_RESV_NOTIFY_RNLPT_REGISTRATION_PREEMPTED" +, +.br +.br +.BI " NVME_RESV_NOTIFY_RNLPT_RESERVATION_RELEASED" +, +.br +.br +.BI " NVME_RESV_NOTIFY_RNLPT_RESERVATION_PREEMPTED" + +}; +.SH Constants +.IP "NVME_RESV_NOTIFY_RNLPT_EMPTY" 12 +.IP "NVME_RESV_NOTIFY_RNLPT_REGISTRATION_PREEMPTED" 12 +.IP "NVME_RESV_NOTIFY_RNLPT_RESERVATION_RELEASED" 12 +.IP "NVME_RESV_NOTIFY_RNLPT_RESERVATION_PREEMPTED" 12 diff --git a/doc/man/nvme_resv_racqa.2 b/doc/man/nvme_resv_racqa.2 new file mode 100644 index 0000000..724eedf --- /dev/null +++ b/doc/man/nvme_resv_racqa.2 @@ -0,0 +1,24 @@ +.TH "libnvme" 9 "enum nvme_resv_racqa" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_resv_racqa \- +.SH SYNOPSIS +enum nvme_resv_racqa { +.br +.BI " NVME_RESERVATION_RACQA_ACQUIRE" +, +.br +.br +.BI " NVME_RESERVATION_RACQA_PREEMPT" +, +.br +.br +.BI " NVME_RESERVATION_RACQA_PREEMPT_AND_ABORT" + +}; +.SH Constants +.IP "NVME_RESERVATION_RACQA_ACQUIRE" 12 +Acquire +.IP "NVME_RESERVATION_RACQA_PREEMPT" 12 +Preempt +.IP "NVME_RESERVATION_RACQA_PREEMPT_AND_ABORT" 12 +Preempt and Abort diff --git a/doc/man/nvme_resv_register.2 b/doc/man/nvme_resv_register.2 new file mode 100644 index 0000000..af51199 --- /dev/null +++ b/doc/man/nvme_resv_register.2 @@ -0,0 +1,15 @@ +.TH "nvme_resv_register" 9 "nvme_resv_register" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_resv_register \- Send an nvme reservation register +.SH SYNOPSIS +.B "int" nvme_resv_register +.BI "(struct nvme_resv_register_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_resv_register_args\fP argument structure +.SH "DESCRIPTION" +The Reservation Register command registers, unregisters, or replaces a +reservation key. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_resv_register_args.2 b/doc/man/nvme_resv_register_args.2 new file mode 100644 index 0000000..5654c8d --- /dev/null +++ b/doc/man/nvme_resv_register_args.2 @@ -0,0 +1,52 @@ +.TH "libnvme" 9 "struct nvme_resv_register_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_resv_register_args \- Arguments for the NVMe Reservation Register command +.SH SYNOPSIS +struct nvme_resv_register_args { +.br +.BI " __u64 crkey;" +.br +.BI " __u64 nrkey;" +.br +.BI " __u32 *result;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u32 nsid;" +.br +.BI " enum nvme_resv_rrega rrega;" +.br +.BI " enum nvme_resv_cptpl cptpl;" +.br +.BI " bool iekey;" +.br +.BI " +}; +.br + +.SH Members +.IP "crkey" 12 +The current reservation key associated with the host +.IP "nrkey" 12 +The new reservation key to be register if action is register or +replace +.IP "result" 12 +The command completion result from CQE dword0 +.IP "args_size" 12 +Size of \fIstruct nvme_resv_register_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "nsid" 12 +Namespace identifier +.IP "rrega" 12 +The registration action, see \fIenum nvme_resv_rrega\fP +.IP "cptpl" 12 +Change persist through power loss, see \fIenum nvme_resv_cptpl\fP +.IP "iekey" 12 +Set to ignore the existing key diff --git a/doc/man/nvme_resv_release.2 b/doc/man/nvme_resv_release.2 new file mode 100644 index 0000000..d656ddd --- /dev/null +++ b/doc/man/nvme_resv_release.2 @@ -0,0 +1,12 @@ +.TH "nvme_resv_release" 9 "nvme_resv_release" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_resv_release \- Send an nvme reservation release +.SH SYNOPSIS +.B "int" nvme_resv_release +.BI "(struct nvme_resv_release_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_resv_release_args\fP argument structure +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_resv_release_args.2 b/doc/man/nvme_resv_release_args.2 new file mode 100644 index 0000000..ad4eeda --- /dev/null +++ b/doc/man/nvme_resv_release_args.2 @@ -0,0 +1,47 @@ +.TH "libnvme" 9 "struct nvme_resv_release_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_resv_release_args \- Arguments for the NVMe Reservation Release Command +.SH SYNOPSIS +struct nvme_resv_release_args { +.br +.BI " __u64 crkey;" +.br +.BI " __u32 *result;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u32 nsid;" +.br +.BI " enum nvme_resv_rtype rtype;" +.br +.BI " enum nvme_resv_rrela rrela;" +.br +.BI " bool iekey;" +.br +.BI " +}; +.br + +.SH Members +.IP "crkey" 12 +The current reservation key to release +.IP "result" 12 +The command completion result from CQE dword0 +.IP "args_size" 12 +Size of \fIstruct nvme_resv_release_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "nsid" 12 +Namespace identifier +.IP "rtype" 12 +The type of reservation to be create, see \fIenum nvme_resv_rtype\fP +.IP "rrela" 12 +Reservation releast action, see \fIenum nvme_resv_rrela\fP +.IP "iekey" 12 +Set to ignore the existing key diff --git a/doc/man/nvme_resv_report.2 b/doc/man/nvme_resv_report.2 new file mode 100644 index 0000000..0e266d7 --- /dev/null +++ b/doc/man/nvme_resv_report.2 @@ -0,0 +1,16 @@ +.TH "nvme_resv_report" 9 "nvme_resv_report" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_resv_report \- Send an nvme reservation report +.SH SYNOPSIS +.B "int" nvme_resv_report +.BI "(struct nvme_resv_report_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +struct nvme_resv_report_args argument structure +.SH "DESCRIPTION" +Returns a Reservation Status data structure to memory that describes the +registration and reservation status of a namespace. See the defintion for +the returned structure, \fIstruct nvme_reservation_status\fP, for more details. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_resv_report_args.2 b/doc/man/nvme_resv_report_args.2 new file mode 100644 index 0000000..f98fd25 --- /dev/null +++ b/doc/man/nvme_resv_report_args.2 @@ -0,0 +1,44 @@ +.TH "libnvme" 9 "struct nvme_resv_report_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_resv_report_args \- Arguments for the NVMe Reservation Report command +.SH SYNOPSIS +struct nvme_resv_report_args { +.br +.BI " __u32 *result;" +.br +.BI " struct nvme_resv_status *report;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u32 nsid;" +.br +.BI " __u32 len;" +.br +.BI " bool eds;" +.br +.BI " +}; +.br + +.SH Members +.IP "result" 12 +The command completion result from CQE dword0 +.IP "report" 12 +The user space destination address to store the reservation +report +.IP "args_size" 12 +Size of \fIstruct nvme_resv_report_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "nsid" 12 +Namespace identifier +.IP "len" 12 +Number of bytes to request transfered with this command +.IP "eds" 12 +Request extended Data Structure diff --git a/doc/man/nvme_resv_rrega.2 b/doc/man/nvme_resv_rrega.2 new file mode 100644 index 0000000..dfce261 --- /dev/null +++ b/doc/man/nvme_resv_rrega.2 @@ -0,0 +1,24 @@ +.TH "libnvme" 9 "enum nvme_resv_rrega" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_resv_rrega \- +.SH SYNOPSIS +enum nvme_resv_rrega { +.br +.BI " NVME_RESERVATION_RREGA_REGISTER_KEY" +, +.br +.br +.BI " NVME_RESERVATION_RREGA_UNREGISTER_KEY" +, +.br +.br +.BI " NVME_RESERVATION_RREGA_REPLACE_KEY" + +}; +.SH Constants +.IP "NVME_RESERVATION_RREGA_REGISTER_KEY" 12 +Register Reservation Key +.IP "NVME_RESERVATION_RREGA_UNREGISTER_KEY" 12 +Unregister Reservation Key +.IP "NVME_RESERVATION_RREGA_REPLACE_KEY" 12 +Replace Reservation Key diff --git a/doc/man/nvme_resv_rrela.2 b/doc/man/nvme_resv_rrela.2 new file mode 100644 index 0000000..b3eb068 --- /dev/null +++ b/doc/man/nvme_resv_rrela.2 @@ -0,0 +1,18 @@ +.TH "libnvme" 9 "enum nvme_resv_rrela" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_resv_rrela \- +.SH SYNOPSIS +enum nvme_resv_rrela { +.br +.BI " NVME_RESERVATION_RRELA_RELEASE" +, +.br +.br +.BI " NVME_RESERVATION_RRELA_CLEAR" + +}; +.SH Constants +.IP "NVME_RESERVATION_RRELA_RELEASE" 12 +Release +.IP "NVME_RESERVATION_RRELA_CLEAR" 12 +Clear diff --git a/doc/man/nvme_resv_rtype.2 b/doc/man/nvme_resv_rtype.2 new file mode 100644 index 0000000..bdff164 --- /dev/null +++ b/doc/man/nvme_resv_rtype.2 @@ -0,0 +1,42 @@ +.TH "libnvme" 9 "enum nvme_resv_rtype" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_resv_rtype \- +.SH SYNOPSIS +enum nvme_resv_rtype { +.br +.BI " NVME_RESERVATION_RTYPE_WE" +, +.br +.br +.BI " NVME_RESERVATION_RTYPE_EA" +, +.br +.br +.BI " NVME_RESERVATION_RTYPE_WERO" +, +.br +.br +.BI " NVME_RESERVATION_RTYPE_EARO" +, +.br +.br +.BI " NVME_RESERVATION_RTYPE_WEAR" +, +.br +.br +.BI " NVME_RESERVATION_RTYPE_EAAR" + +}; +.SH Constants +.IP "NVME_RESERVATION_RTYPE_WE" 12 +Write Exclusive Reservation +.IP "NVME_RESERVATION_RTYPE_EA" 12 +Exclusive Access Reservation +.IP "NVME_RESERVATION_RTYPE_WERO" 12 +Write Exclusive - Registrants Only Reservation +.IP "NVME_RESERVATION_RTYPE_EARO" 12 +Exclusive Access - Registrants Only Reservation +.IP "NVME_RESERVATION_RTYPE_WEAR" 12 +Write Exclusive - All Registrants Reservation +.IP "NVME_RESERVATION_RTYPE_EAAR" 12 +Exclusive Access - All Registrants Reservation diff --git a/doc/man/nvme_resv_status.2 b/doc/man/nvme_resv_status.2 new file mode 100644 index 0000000..cdb117d --- /dev/null +++ b/doc/man/nvme_resv_status.2 @@ -0,0 +1,59 @@ +.TH "libnvme" 9 "struct nvme_resv_status" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_resv_status \- +.SH SYNOPSIS +struct nvme_resv_status { +.br +.BI " __le32 gen;" +.br +.BI " __u8 rtype;" +.br +.BI " __u8 regctl[2];" +.br +.BI " __u8 rsvd7[2];" +.br +.BI " __u8 ptpls;" +.br +.BI " __u8 rsvd10[14];" +.br +.BI " union {" +.br +.BI " struct {" +.br +.BI " __u8 rsvd24[40];" +.br +.BI " struct nvme_registered_ctrl_ext regctl_eds[0];" +.br +.BI " };" +.br +.BI " struct nvme_registered_ctrl regctl_ds[0];" +.br +.BI " };" +.br +.BI " +}; +.br + +.SH Members +.IP "gen" 12 +Generation +.IP "rtype" 12 +Reservation Type +.IP "regctl" 12 +Number of Registered Controllers +.IP "rsvd7" 12 +Reserved +.IP "ptpls" 12 +Persist Through Power Loss State +.IP "rsvd10" 12 +Reserved +.IP "{unnamed_union}" 12 +anonymous +.IP "{unnamed_struct}" 12 +anonymous +.IP "rsvd24" 12 +Reserved +.IP "regctl_eds" 12 +Registered Controller Extended Data Structure +.IP "regctl_ds" 12 +Registered Controller Data Structure diff --git a/doc/man/nvme_sanitize_compln_event.2 b/doc/man/nvme_sanitize_compln_event.2 new file mode 100644 index 0000000..456e3bc --- /dev/null +++ b/doc/man/nvme_sanitize_compln_event.2 @@ -0,0 +1,27 @@ +.TH "libnvme" 9 "struct nvme_sanitize_compln_event" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_sanitize_compln_event \- +.SH SYNOPSIS +struct nvme_sanitize_compln_event { +.br +.BI " __le16 sani_prog;" +.br +.BI " __le16 sani_status;" +.br +.BI " __le16 cmpln_info;" +.br +.BI " __u8 rsvd6[2];" +.br +.BI " +}; +.br + +.SH Members +.IP "sani_prog" 12 +Sanitize Progress +.IP "sani_status" 12 +Sanitize Status +.IP "cmpln_info" 12 +Completion Information +.IP "rsvd6" 12 +Reserved diff --git a/doc/man/nvme_sanitize_log_page.2 b/doc/man/nvme_sanitize_log_page.2 new file mode 100644 index 0000000..1a915f5 --- /dev/null +++ b/doc/man/nvme_sanitize_log_page.2 @@ -0,0 +1,106 @@ +.TH "libnvme" 9 "struct nvme_sanitize_log_page" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_sanitize_log_page \- Sanitize Status (Log Identifier 81h) +.SH SYNOPSIS +struct nvme_sanitize_log_page { +.br +.BI " __le16 sprog;" +.br +.BI " __le16 sstat;" +.br +.BI " __le32 scdw10;" +.br +.BI " __le32 eto;" +.br +.BI " __le32 etbe;" +.br +.BI " __le32 etce;" +.br +.BI " __le32 etond;" +.br +.BI " __le32 etbend;" +.br +.BI " __le32 etcend;" +.br +.BI " __u8 rsvd32[480];" +.br +.BI " +}; +.br + +.SH Members +.IP "sprog" 12 +Sanitize Progress (SPROG): indicates the fraction complete of the +sanitize operation. The value is a numerator of the fraction +complete that has 65,536 (10000h) as its denominator. This value +shall be set to FFFFh if the \fIsstat\fP field is not set to +NVME_SANITIZE_SSTAT_STATUS_IN_PROGESS. +.IP "sstat" 12 +Sanitize Status (SSTAT): indicates the status associated with +the most recent sanitize operation. See \fIenum nvme_sanitize_sstat\fP. +.IP "scdw10" 12 +Sanitize Command Dword 10 Information (SCDW10): contains the value +of the Command Dword 10 field of the Sanitize command that started +the sanitize operation. +.IP "eto" 12 +Estimated Time For Overwrite: indicates the number of seconds required +to complete an Overwrite sanitize operation with 16 passes in +the background when the No-Deallocate Modifies Media After Sanitize +field is not set to 10b. A value of 0h indicates that the sanitize +operation is expected to be completed in the background when the +Sanitize command that started that operation is completed. A value +of FFFFFFFFh indicates that no time period is reported. +.IP "etbe" 12 +Estimated Time For Block Erase: indicates the number of seconds +required to complete a Block Erase sanitize operation in the +background when the No-Deallocate Modifies Media After Sanitize +field is not set to 10b. A value of 0h indicates that the sanitize +operation is expected to be completed in the background when the +Sanitize command that started that operation is completed. +A value of FFFFFFFFh indicates that no time period is reported. +.IP "etce" 12 +Estimated Time For Crypto Erase: indicates the number of seconds +required to complete a Crypto Erase sanitize operation in the +background when the No-Deallocate Modifies Media After Sanitize +field is not set to 10b. A value of 0h indicates that the sanitize +operation is expected to be completed in the background when the +Sanitize command that started that operation is completed. +A value of FFFFFFFFh indicates that no time period is reported. +.IP "etond" 12 +Estimated Time For Overwrite With No-Deallocate Media Modification: +indicates the number of seconds required to complete an Overwrite +sanitize operation and the associated additional media modification +after the Overwrite sanitize operation in the background when +the No-Deallocate After Sanitize bit was set to 1 in the Sanitize +command that requested the Overwrite sanitize operation; and +the No-Deallocate Modifies Media After Sanitize field is set to 10b. +A value of 0h indicates that the sanitize operation is expected +to be completed in the background when the Sanitize command that +started that operation is completed. A value of FFFFFFFFh indicates +that no time period is reported. +.IP "etbend" 12 +Estimated Time For Block Erase With No-Deallocate Media Modification: +indicates the number of seconds required to complete a Block Erase +sanitize operation and the associated additional media modification +after the Block Erase sanitize operation in the background when +the No-Deallocate After Sanitize bit was set to 1 in the Sanitize +command that requested the Overwrite sanitize operation; and +the No-Deallocate Modifies Media After Sanitize field is set to 10b. +A value of 0h indicates that the sanitize operation is expected +to be completed in the background when the Sanitize command that +started that operation is completed. A value of FFFFFFFFh indicates +that no time period is reported. +.IP "etcend" 12 +Estimated Time For Crypto Erase With No-Deallocate Media Modification: +indicates the number of seconds required to complete a Crypto Erase +sanitize operation and the associated additional media modification +after the Crypto Erase sanitize operation in the background when +the No-Deallocate After Sanitize bit was set to 1 in the Sanitize +command that requested the Overwrite sanitize operation; and +the No-Deallocate Modifies Media After Sanitize field is set to 10b. +A value of 0h indicates that the sanitize operation is expected +to be completed in the background when the Sanitize command that +started that operation is completed. A value of FFFFFFFFh indicates +that no time period is reported. +.IP "rsvd32" 12 +Reserved diff --git a/doc/man/nvme_sanitize_nvm.2 b/doc/man/nvme_sanitize_nvm.2 new file mode 100644 index 0000000..89dbcf5 --- /dev/null +++ b/doc/man/nvme_sanitize_nvm.2 @@ -0,0 +1,22 @@ +.TH "nvme_sanitize_nvm" 9 "nvme_sanitize_nvm" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_sanitize_nvm \- Start a sanitize operation +.SH SYNOPSIS +.B "int" nvme_sanitize_nvm +.BI "(struct nvme_sanitize_nvm_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_sanitize_nvm_args\fP argument structure +.SH "DESCRIPTION" +A sanitize operation alters all user data in the NVM subsystem such that +recovery of any previous user data from any cache, the non-volatile media, +or any Controller Memory Buffer is not possible. + +The Sanitize command starts a sanitize operation or to recover from a +previously failed sanitize operation. The sanitize operation types that may +be supported are Block Erase, Crypto Erase, and Overwrite. All sanitize +operations are processed in the background, i.e., completion of the sanitize +command does not indicate completion of the sanitize operation. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_sanitize_nvm_args.2 b/doc/man/nvme_sanitize_nvm_args.2 new file mode 100644 index 0000000..1a414db --- /dev/null +++ b/doc/man/nvme_sanitize_nvm_args.2 @@ -0,0 +1,51 @@ +.TH "libnvme" 9 "struct nvme_sanitize_nvm_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_sanitize_nvm_args \- Arguments for the NVMe Sanitize NVM command +.SH SYNOPSIS +struct nvme_sanitize_nvm_args { +.br +.BI " __u32 *result;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " enum nvme_sanitize_sanact sanact;" +.br +.BI " __u32 ovrpat;" +.br +.BI " bool ause;" +.br +.BI " __u8 owpass;" +.br +.BI " bool oipbp;" +.br +.BI " bool nodas;" +.br +.BI " +}; +.br + +.SH Members +.IP "result" 12 +The command completion result from CQE dword0 +.IP "args_size" 12 +Size of \fIstruct nvme_sanitize_nvm_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "sanact" 12 +Sanitize action, see \fIenum nvme_sanitize_sanact\fP +.IP "ovrpat" 12 +Overwrite pattern +.IP "ause" 12 +Set to allow unrestriced sanitize exit +.IP "owpass" 12 +Overwrite pass count +.IP "oipbp" 12 +Set to overwrite invert pattern between passes +.IP "nodas" 12 +Set to not deallocate blocks after sanitizing diff --git a/doc/man/nvme_sanitize_sanact.2 b/doc/man/nvme_sanitize_sanact.2 new file mode 100644 index 0000000..13d1163 --- /dev/null +++ b/doc/man/nvme_sanitize_sanact.2 @@ -0,0 +1,30 @@ +.TH "libnvme" 9 "enum nvme_sanitize_sanact" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_sanitize_sanact \- Sanitize Action +.SH SYNOPSIS +enum nvme_sanitize_sanact { +.br +.BI " NVME_SANITIZE_SANACT_EXIT_FAILURE" +, +.br +.br +.BI " NVME_SANITIZE_SANACT_START_BLOCK_ERASE" +, +.br +.br +.BI " NVME_SANITIZE_SANACT_START_OVERWRITE" +, +.br +.br +.BI " NVME_SANITIZE_SANACT_START_CRYPTO_ERASE" + +}; +.SH Constants +.IP "NVME_SANITIZE_SANACT_EXIT_FAILURE" 12 +Exit Failure Mode. +.IP "NVME_SANITIZE_SANACT_START_BLOCK_ERASE" 12 +Start a Block Erase sanitize operation. +.IP "NVME_SANITIZE_SANACT_START_OVERWRITE" 12 +Start an Overwrite sanitize operation. +.IP "NVME_SANITIZE_SANACT_START_CRYPTO_ERASE" 12 +Start a Crypto Erase sanitize operation. diff --git a/doc/man/nvme_sanitize_sstat.2 b/doc/man/nvme_sanitize_sstat.2 new file mode 100644 index 0000000..abe4334 --- /dev/null +++ b/doc/man/nvme_sanitize_sstat.2 @@ -0,0 +1,105 @@ +.TH "libnvme" 9 "enum nvme_sanitize_sstat" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_sanitize_sstat \- Sanitize Status (SSTAT) +.SH SYNOPSIS +enum nvme_sanitize_sstat { +.br +.BI " NVME_SANITIZE_SSTAT_STATUS_SHIFT" +, +.br +.br +.BI " NVME_SANITIZE_SSTAT_STATUS_MASK" +, +.br +.br +.BI " NVME_SANITIZE_SSTAT_STATUS_NEVER_SANITIZED" +, +.br +.br +.BI " NVME_SANITIZE_SSTAT_STATUS_COMPLETE_SUCCESS" +, +.br +.br +.BI " NVME_SANITIZE_SSTAT_STATUS_IN_PROGESS" +, +.br +.br +.BI " NVME_SANITIZE_SSTAT_STATUS_COMPLETED_FAILED" +, +.br +.br +.BI " NVME_SANITIZE_SSTAT_STATUS_ND_COMPLETE_SUCCESS" +, +.br +.br +.BI " NVME_SANITIZE_SSTAT_COMPLETED_PASSES_SHIFT" +, +.br +.br +.BI " NVME_SANITIZE_SSTAT_COMPLETED_PASSES_MASK" +, +.br +.br +.BI " NVME_SANITIZE_SSTAT_GLOBAL_DATA_ERASED_SHIFT" +, +.br +.br +.BI " NVME_SANITIZE_SSTAT_GLOBAL_DATA_ERASED_MASK" +, +.br +.br +.BI " NVME_SANITIZE_SSTAT_GLOBAL_DATA_ERASED" + +}; +.SH Constants +.IP "NVME_SANITIZE_SSTAT_STATUS_SHIFT" 12 +Shift amount to get the status value of +the most recent sanitize operation from +the \fIstruct nvme_sanitize_log_page\fP.sstat +field. +.IP "NVME_SANITIZE_SSTAT_STATUS_MASK" 12 +Mask to get the status value of the most +recent sanitize operation. +.IP "NVME_SANITIZE_SSTAT_STATUS_NEVER_SANITIZED" 12 +The NVM subsystem has never been +sanitized. +.IP "NVME_SANITIZE_SSTAT_STATUS_COMPLETE_SUCCESS" 12 +The most recent sanitize operation +completed successfully including any +additional media modification. +.IP "NVME_SANITIZE_SSTAT_STATUS_IN_PROGESS" 12 +A sanitize operation is currently in progress. +.IP "NVME_SANITIZE_SSTAT_STATUS_COMPLETED_FAILED" 12 +The most recent sanitize operation +failed. +.IP "NVME_SANITIZE_SSTAT_STATUS_ND_COMPLETE_SUCCESS" 12 +The most recent sanitize operation +for which No-Deallocate After Sanitize was +requested has completed successfully with +deallocation of all user data. +.IP "NVME_SANITIZE_SSTAT_COMPLETED_PASSES_SHIFT" 12 +Shift amount to get the number +of completed passes if the most recent +sanitize operation was an Overwrite. This +value shall be cleared to 0h if the most +recent sanitize operation was not +an Overwrite. +.IP "NVME_SANITIZE_SSTAT_COMPLETED_PASSES_MASK" 12 +Mask to get the number of completed +passes. +.IP "NVME_SANITIZE_SSTAT_GLOBAL_DATA_ERASED_SHIFT" 12 +Shift amount to get the Global +Data Erased value from the +\fIstruct nvme_sanitize_log_page\fP.sstat field. +.IP "NVME_SANITIZE_SSTAT_GLOBAL_DATA_ERASED_MASK" 12 +Mask to get the Global Data Erased +value. +.IP "NVME_SANITIZE_SSTAT_GLOBAL_DATA_ERASED" 12 +Global Data Erased: if set, then no +namespace user data in the NVM subsystem +has been written to and no Persistent +Memory Region in the NVM subsystem has +been enabled since being manufactured and +the NVM subsystem has never been sanitized; +or since the most recent successful sanitize +operation. diff --git a/doc/man/nvme_sanitize_start_event.2 b/doc/man/nvme_sanitize_start_event.2 new file mode 100644 index 0000000..36ea6ea --- /dev/null +++ b/doc/man/nvme_sanitize_start_event.2 @@ -0,0 +1,23 @@ +.TH "libnvme" 9 "struct nvme_sanitize_start_event" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_sanitize_start_event \- +.SH SYNOPSIS +struct nvme_sanitize_start_event { +.br +.BI " __le32 sani_cap;" +.br +.BI " __le32 sani_cdw10;" +.br +.BI " __le32 sani_cdw11;" +.br +.BI " +}; +.br + +.SH Members +.IP "sani_cap" 12 +SANICAP +.IP "sani_cdw10" 12 +Sanitize CDW10 +.IP "sani_cdw11" 12 +Sanitize CDW11 diff --git a/doc/man/nvme_scan.2 b/doc/man/nvme_scan.2 new file mode 100644 index 0000000..962e786 --- /dev/null +++ b/doc/man/nvme_scan.2 @@ -0,0 +1,11 @@ +.TH "nvme_scan" 9 "nvme_scan" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_scan \- Scan NVMe topology +.SH SYNOPSIS +.B "nvme_root_t" nvme_scan +.BI "(const char *config_file " ");" +.SH ARGUMENTS +.IP "config_file" 12 +Configuration file +.SH "RETURN" +nvme_root_t object of found elements diff --git a/doc/man/nvme_scan_ctrl.2 b/doc/man/nvme_scan_ctrl.2 new file mode 100644 index 0000000..bef86d0 --- /dev/null +++ b/doc/man/nvme_scan_ctrl.2 @@ -0,0 +1,16 @@ +.TH "nvme_scan_ctrl" 9 "nvme_scan_ctrl" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_scan_ctrl \- Scan on a controller +.SH SYNOPSIS +.B "nvme_ctrl_t" nvme_scan_ctrl +.BI "(nvme_root_t r " "," +.BI "const char *name " ");" +.SH ARGUMENTS +.IP "r" 12 +nvme_root_t object +.IP "name" 12 +Name of the controller +.SH "DESCRIPTION" +Scans a controller with sysfs name \fIname\fP and add it to \fIr\fP. +.SH "RETURN" +nvme_ctrl_t object diff --git a/doc/man/nvme_scan_ctrl_namespace_paths.2 b/doc/man/nvme_scan_ctrl_namespace_paths.2 new file mode 100644 index 0000000..db2549e --- /dev/null +++ b/doc/man/nvme_scan_ctrl_namespace_paths.2 @@ -0,0 +1,14 @@ +.TH "nvme_scan_ctrl_namespace_paths" 9 "nvme_scan_ctrl_namespace_paths" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_scan_ctrl_namespace_paths \- Scan for namespace paths in a controller +.SH SYNOPSIS +.B "int" nvme_scan_ctrl_namespace_paths +.BI "(nvme_ctrl_t c " "," +.BI "struct dirent ***paths " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller to scan +.IP "paths" 12 +Pointer to array of dirents +.SH "RETURN" +number of entries in \fIpaths\fP diff --git a/doc/man/nvme_scan_ctrl_namespaces.2 b/doc/man/nvme_scan_ctrl_namespaces.2 new file mode 100644 index 0000000..aba1eca --- /dev/null +++ b/doc/man/nvme_scan_ctrl_namespaces.2 @@ -0,0 +1,14 @@ +.TH "nvme_scan_ctrl_namespaces" 9 "nvme_scan_ctrl_namespaces" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_scan_ctrl_namespaces \- Scan for namespaces in a controller +.SH SYNOPSIS +.B "int" nvme_scan_ctrl_namespaces +.BI "(nvme_ctrl_t c " "," +.BI "struct dirent ***ns " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller to scan +.IP "ns" 12 +Pointer to array of dirents +.SH "RETURN" +number of entries in \fIns\fP diff --git a/doc/man/nvme_scan_ctrls.2 b/doc/man/nvme_scan_ctrls.2 new file mode 100644 index 0000000..9c04e6c --- /dev/null +++ b/doc/man/nvme_scan_ctrls.2 @@ -0,0 +1,11 @@ +.TH "nvme_scan_ctrls" 9 "nvme_scan_ctrls" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_scan_ctrls \- Scan for controllers +.SH SYNOPSIS +.B "int" nvme_scan_ctrls +.BI "(struct dirent ***ctrls " ");" +.SH ARGUMENTS +.IP "ctrls" 12 +Pointer to array of dirents +.SH "RETURN" +number of entries in \fIctrls\fP diff --git a/doc/man/nvme_scan_namespace.2 b/doc/man/nvme_scan_namespace.2 new file mode 100644 index 0000000..a4c8f83 --- /dev/null +++ b/doc/man/nvme_scan_namespace.2 @@ -0,0 +1,11 @@ +.TH "nvme_scan_namespace" 9 "nvme_scan_namespace" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_scan_namespace \- scan namespace based on sysfs name +.SH SYNOPSIS +.B "nvme_ns_t" nvme_scan_namespace +.BI "(const char *name " ");" +.SH ARGUMENTS +.IP "name" 12 +sysfs name of the namespace to scan +.SH "RETURN" +nvme_ns_t object or NULL if not found. diff --git a/doc/man/nvme_scan_subsystem_namespaces.2 b/doc/man/nvme_scan_subsystem_namespaces.2 new file mode 100644 index 0000000..2915fa1 --- /dev/null +++ b/doc/man/nvme_scan_subsystem_namespaces.2 @@ -0,0 +1,14 @@ +.TH "nvme_scan_subsystem_namespaces" 9 "nvme_scan_subsystem_namespaces" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_scan_subsystem_namespaces \- Scan for namespaces in a subsystem +.SH SYNOPSIS +.B "int" nvme_scan_subsystem_namespaces +.BI "(nvme_subsystem_t s " "," +.BI "struct dirent ***ns " ");" +.SH ARGUMENTS +.IP "s" 12 +Subsystem to scan +.IP "ns" 12 +Pointer to array of dirents +.SH "RETURN" +number of entries in \fIns\fP diff --git a/doc/man/nvme_scan_subsystems.2 b/doc/man/nvme_scan_subsystems.2 new file mode 100644 index 0000000..48e0eb8 --- /dev/null +++ b/doc/man/nvme_scan_subsystems.2 @@ -0,0 +1,11 @@ +.TH "nvme_scan_subsystems" 9 "nvme_scan_subsystems" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_scan_subsystems \- Scan for subsystems +.SH SYNOPSIS +.B "int" nvme_scan_subsystems +.BI "(struct dirent ***subsys " ");" +.SH ARGUMENTS +.IP "subsys" 12 +Pointer to array of dirents +.SH "RETURN" +number of entries in \fIsubsys\fP diff --git a/doc/man/nvme_scan_topology.2 b/doc/man/nvme_scan_topology.2 new file mode 100644 index 0000000..602d8ae --- /dev/null +++ b/doc/man/nvme_scan_topology.2 @@ -0,0 +1,20 @@ +.TH "nvme_scan_topology" 9 "nvme_scan_topology" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_scan_topology \- Scan NVMe topology and apply filter +.SH SYNOPSIS +.B "int" nvme_scan_topology +.BI "(nvme_root_t r " "," +.BI "nvme_scan_filter_t f " "," +.BI "void *f_args " ");" +.SH ARGUMENTS +.IP "r" 12 +nvme_root_t object +.IP "f" 12 +filter to apply +.IP "f_args" 12 +user-specified argument to \fIf\fP +.SH "DESCRIPTION" +Scans the NVMe topology and filters out the resulting elements +by applying \fIf\fP. +.SH "RETURN" +Number of elements scanned diff --git a/doc/man/nvme_secondary_ctrl.2 b/doc/man/nvme_secondary_ctrl.2 new file mode 100644 index 0000000..b6eb2bd --- /dev/null +++ b/doc/man/nvme_secondary_ctrl.2 @@ -0,0 +1,43 @@ +.TH "libnvme" 9 "struct nvme_secondary_ctrl" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_secondary_ctrl \- +.SH SYNOPSIS +struct nvme_secondary_ctrl { +.br +.BI " __le16 scid;" +.br +.BI " __le16 pcid;" +.br +.BI " __u8 scs;" +.br +.BI " __u8 rsvd5[3];" +.br +.BI " __le16 vfn;" +.br +.BI " __le16 nvq;" +.br +.BI " __le16 nvi;" +.br +.BI " __u8 rsvd14[18];" +.br +.BI " +}; +.br + +.SH Members +.IP "scid" 12 +Secondary Controller Identifier +.IP "pcid" 12 +Primary Controller Identifier +.IP "scs" 12 +Secondary Controller State +.IP "rsvd5" 12 +Reserved +.IP "vfn" 12 +Virtual Function Number +.IP "nvq" 12 +Number of VQ Flexible Resources Assigned +.IP "nvi" 12 +Number of VI Flexible Resources Assigned +.IP "rsvd14" 12 +Reserved diff --git a/doc/man/nvme_secondary_ctrl_list.2 b/doc/man/nvme_secondary_ctrl_list.2 new file mode 100644 index 0000000..69afc87 --- /dev/null +++ b/doc/man/nvme_secondary_ctrl_list.2 @@ -0,0 +1,23 @@ +.TH "libnvme" 9 "struct nvme_secondary_ctrl_list" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_secondary_ctrl_list \- +.SH SYNOPSIS +struct nvme_secondary_ctrl_list { +.br +.BI " __u8 num;" +.br +.BI " __u8 rsvd[31];" +.br +.BI " struct nvme_secondary_ctrl sc_entry[NVME_ID_SECONDARY_CTRL_MAX];" +.br +.BI " +}; +.br + +.SH Members +.IP "num" 12 +Number of Identifiers +.IP "rsvd" 12 +Reserved +.IP "sc_entry" 12 +Secondary Controller Entry diff --git a/doc/man/nvme_security_receive.2 b/doc/man/nvme_security_receive.2 new file mode 100644 index 0000000..008e6d0 --- /dev/null +++ b/doc/man/nvme_security_receive.2 @@ -0,0 +1,12 @@ +.TH "nvme_security_receive" 9 "nvme_security_receive" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_security_receive \- +.SH SYNOPSIS +.B "int" nvme_security_receive +.BI "(struct nvme_security_receive_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_security_recevice\fP argument structure +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_security_receive_args.2 b/doc/man/nvme_security_receive_args.2 new file mode 100644 index 0000000..220d3ce --- /dev/null +++ b/doc/man/nvme_security_receive_args.2 @@ -0,0 +1,59 @@ +.TH "libnvme" 9 "struct nvme_security_receive_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_security_receive_args \- Arguments for the NVMe Security Receive command +.SH SYNOPSIS +struct nvme_security_receive_args { +.br +.BI " __u32 *result;" +.br +.BI " void *data;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u32 nsid;" +.br +.BI " __u32 al;" +.br +.BI " __u32 data_len;" +.br +.BI " __u8 nssf;" +.br +.BI " __u8 spsp0;" +.br +.BI " __u8 spsp1;" +.br +.BI " __u8 secp;" +.br +.BI " +}; +.br + +.SH Members +.IP "result" 12 +The command completion result from CQE dword0 +.IP "data" 12 +Security data payload to send +.IP "args_size" 12 +Size of \fIstruct nvme_security_receive_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "nsid" 12 +Namespace ID to issue security command on +.IP "al" 12 +Protocol specific allocation length +.IP "data_len" 12 +Data length of the payload in bytes +.IP "nssf" 12 +NVMe Security Specific field +.IP "spsp0" 12 +Security Protocol Specific field +.IP "spsp1" 12 +Security Protocol Specific field +.IP "secp" 12 +Security Protocol diff --git a/doc/man/nvme_security_send.2 b/doc/man/nvme_security_send.2 new file mode 100644 index 0000000..cadb73f --- /dev/null +++ b/doc/man/nvme_security_send.2 @@ -0,0 +1,21 @@ +.TH "nvme_security_send" 9 "nvme_security_send" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_security_send \- +.SH SYNOPSIS +.B "int" nvme_security_send +.BI "(struct nvme_security_send_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_security_send\fP argument structure +.SH "DESCRIPTION" +The Security Send command transfers security protocol data to the +controller. The data structure transferred to the controller as part of this +command contains security protocol specific commands to be performed by the +controller. The data structure transferred may also contain data or +parameters associated with the security protocol commands. + +The security data is protocol specific and is not defined by the NVMe +specification. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_security_send_args.2 b/doc/man/nvme_security_send_args.2 new file mode 100644 index 0000000..ac9272b --- /dev/null +++ b/doc/man/nvme_security_send_args.2 @@ -0,0 +1,59 @@ +.TH "libnvme" 9 "struct nvme_security_send_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_security_send_args \- Arguments for the NVMe Security Send command +.SH SYNOPSIS +struct nvme_security_send_args { +.br +.BI " __u32 *result;" +.br +.BI " void *data;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u32 nsid;" +.br +.BI " __u32 tl;" +.br +.BI " __u32 data_len;" +.br +.BI " __u8 nssf;" +.br +.BI " __u8 spsp0;" +.br +.BI " __u8 spsp1;" +.br +.BI " __u8 secp;" +.br +.BI " +}; +.br + +.SH Members +.IP "result" 12 +The command completion result from CQE dword0 +.IP "data" 12 +Security data payload to send +.IP "args_size" 12 +Size of \fIstruct nvme_security_send_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "nsid" 12 +Namespace ID to issue security command on +.IP "tl" 12 +Protocol specific transfer length +.IP "data_len" 12 +Data length of the payload in bytes +.IP "nssf" 12 +NVMe Security Specific field +.IP "spsp0" 12 +Security Protocol Specific field +.IP "spsp1" 12 +Security Protocol Specific field +.IP "secp" 12 +Security Protocol diff --git a/doc/man/nvme_self_test_log.2 b/doc/man/nvme_self_test_log.2 new file mode 100644 index 0000000..f46cd21 --- /dev/null +++ b/doc/man/nvme_self_test_log.2 @@ -0,0 +1,43 @@ +.TH "libnvme" 9 "struct nvme_self_test_log" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_self_test_log \- Device Self-test (Log Identifier 06h) +.SH SYNOPSIS +struct nvme_self_test_log { +.br +.BI " __u8 current_operation;" +.br +.BI " __u8 completion;" +.br +.BI " __u8 rsvd[2];" +.br +.BI " struct nvme_st_result result[NVME_LOG_ST_MAX_RESULTS];" +.br +.BI " +}; +.br + +.SH Members +.IP "current_operation" 12 +Current Device Self-Test Operation: indicates the status +of the current device self-test operation. If a device +self-test operation is in process (i.e., this field is set +to #NVME_ST_CURR_OP_SHORT or #NVME_ST_CURR_OP_EXTENDED), +then the controller shall not set this field to +#NVME_ST_CURR_OP_NOT_RUNNING until a new Self-test Result +Data Structure is created (i.e., if a device self-test +operation completes or is aborted, then the controller +shall create a Self-test Result Data Structure prior to +setting this field to #NVME_ST_CURR_OP_NOT_RUNNING). +See \fIenum nvme_st_curr_op\fP. +.IP "completion" 12 +Current Device Self-Test Completion: indicates the percentage +of the device self-test operation that is complete (e.g., +a value of 25 indicates that 25% of the device self-test +operation is complete and 75% remains to be tested). +If the \fIcurrent_operation\fP field is cleared to +#NVME_ST_CURR_OP_NOT_RUNNING (indicating there is no device +self-test operation in progress), then this field is ignored. +.IP "rsvd" 12 +Reserved +.IP "result" 12 +Self-test Result Data Structures, see \fIstruct nvme_st_result\fP. diff --git a/doc/man/nvme_set_feature_event.2 b/doc/man/nvme_set_feature_event.2 new file mode 100644 index 0000000..00050af --- /dev/null +++ b/doc/man/nvme_set_feature_event.2 @@ -0,0 +1,19 @@ +.TH "libnvme" 9 "struct nvme_set_feature_event" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_set_feature_event \- +.SH SYNOPSIS +struct nvme_set_feature_event { +.br +.BI " __le32 layout;" +.br +.BI " __le32 cdw_mem[0];" +.br +.BI " +}; +.br + +.SH Members +.IP "layout" 12 +Set Feature Event Layout +.IP "cdw_mem" 12 +Command Dwords Memory buffer diff --git a/doc/man/nvme_set_features.2 b/doc/man/nvme_set_features.2 new file mode 100644 index 0000000..9a41c06 --- /dev/null +++ b/doc/man/nvme_set_features.2 @@ -0,0 +1,12 @@ +.TH "nvme_set_features" 9 "nvme_set_features" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features \- Set a feature attribute +.SH SYNOPSIS +.B "int" nvme_set_features +.BI "(struct nvme_set_features_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_set_features_args\fP argument structure +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_arbitration.2 b/doc/man/nvme_set_features_arbitration.2 new file mode 100644 index 0000000..141d152 --- /dev/null +++ b/doc/man/nvme_set_features_arbitration.2 @@ -0,0 +1,30 @@ +.TH "nvme_set_features_arbitration" 9 "nvme_set_features_arbitration" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_arbitration \- +.SH SYNOPSIS +.B "int" nvme_set_features_arbitration +.BI "(int fd " "," +.BI "__u8 ab " "," +.BI "__u8 lpw " "," +.BI "__u8 mpw " "," +.BI "__u8 hpw " "," +.BI "bool save " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "ab" 12 +Arbitration Burst +.IP "lpw" 12 +Low Priority Weight +.IP "mpw" 12 +Medium Priority Weight +.IP "hpw" 12 +High Priority Weight +.IP "save" 12 +Save value across power states +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_args.2 b/doc/man/nvme_set_features_args.2 new file mode 100644 index 0000000..9c15083 --- /dev/null +++ b/doc/man/nvme_set_features_args.2 @@ -0,0 +1,65 @@ +.TH "libnvme" 9 "struct nvme_set_features_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_set_features_args \- Arguments for the NVMe Admin Set Feature command +.SH SYNOPSIS +struct nvme_set_features_args { +.br +.BI " __u32 *result;" +.br +.BI " void *data;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u32 nsid;" +.br +.BI " __u32 cdw11;" +.br +.BI " __u32 cdw12;" +.br +.BI " __u32 cdw13;" +.br +.BI " __u32 cdw15;" +.br +.BI " __u32 data_len;" +.br +.BI " bool save;" +.br +.BI " __u8 uuidx;" +.br +.BI " __u8 fid;" +.br +.BI " +}; +.br + +.SH Members +.IP "result" 12 +The command completion result from CQE dword0 +.IP "data" 12 +User address of feature data, if applicable +.IP "args_size" 12 +Size of \fIstruct nvme_set_features_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "nsid" 12 +Namespace ID, if applicable +.IP "cdw11" 12 +Value to set the feature to +.IP "cdw12" 12 +Feature specific command dword12 field +.IP "cdw15" 12 +Feature specific command dword15 field +.IP "data_len" 12 +Length of feature data, if applicable, in bytes +.IP "save" 12 +Save value across power states +.IP "uuidx" 12 +UUID Index for differentiating vendor specific encoding +.IP "fid" 12 +Feature identifier diff --git a/doc/man/nvme_set_features_async_event.2 b/doc/man/nvme_set_features_async_event.2 new file mode 100644 index 0000000..e8084db --- /dev/null +++ b/doc/man/nvme_set_features_async_event.2 @@ -0,0 +1,21 @@ +.TH "nvme_set_features_async_event" 9 "nvme_set_features_async_event" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_async_event \- +.SH SYNOPSIS +.B "int" nvme_set_features_async_event +.BI "(int fd " "," +.BI "__u32 events " "," +.BI "bool save " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "events" 12 +Events to enable +.IP "save" 12 +Save value across power states +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_auto_pst.2 b/doc/man/nvme_set_features_auto_pst.2 new file mode 100644 index 0000000..21597e2 --- /dev/null +++ b/doc/man/nvme_set_features_auto_pst.2 @@ -0,0 +1,24 @@ +.TH "nvme_set_features_auto_pst" 9 "nvme_set_features_auto_pst" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_auto_pst \- +.SH SYNOPSIS +.B "int" nvme_set_features_auto_pst +.BI "(int fd " "," +.BI "bool apste " "," +.BI "bool save " "," +.BI "struct nvme_feat_auto_pst *apst " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "apste" 12 +Autonomous Power State Transition Enable +.IP "save" 12 +Save value across power states +.IP "apst" 12 +Autonomous Power State Transition +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_data.2 b/doc/man/nvme_set_features_data.2 new file mode 100644 index 0000000..43e81bf --- /dev/null +++ b/doc/man/nvme_set_features_data.2 @@ -0,0 +1,30 @@ +.TH "nvme_set_features_data" 9 "nvme_set_features_data" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_data \- Helper function for @nvme_set_features() +.SH SYNOPSIS +.B "int" nvme_set_features_data +.BI "(int fd " "," +.BI "__u8 fid " "," +.BI "__u32 nsid " "," +.BI "__u32 cdw11 " "," +.BI "bool save " "," +.BI "__u32 data_len " "," +.BI "void *data " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "fid" 12 +Feature identifier +.IP "nsid" 12 +Namespace ID, if applicable +.IP "cdw11" 12 +Value to set the feature to +.IP "save" 12 +Save value across power states +.IP "data_len" 12 +Length of feature data, if applicable, in bytes +.IP "data" 12 +User address of feature data, if applicable +.IP "result" 12 +The command completion result from CQE dword0 diff --git a/doc/man/nvme_set_features_endurance_evt_cfg.2 b/doc/man/nvme_set_features_endurance_evt_cfg.2 new file mode 100644 index 0000000..c8e796a --- /dev/null +++ b/doc/man/nvme_set_features_endurance_evt_cfg.2 @@ -0,0 +1,24 @@ +.TH "nvme_set_features_endurance_evt_cfg" 9 "nvme_set_features_endurance_evt_cfg" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_endurance_evt_cfg \- +.SH SYNOPSIS +.B "int" nvme_set_features_endurance_evt_cfg +.BI "(int fd " "," +.BI "__u16 endgid " "," +.BI "__u8 egwarn " "," +.BI "bool save " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "endgid" 12 +Endurance Group Identifier +.IP "egwarn" 12 +Flags to enable warning, see \fIenum nvme_eg_critical_warning_flags\fP +.IP "save" 12 +Save value across power states +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_err_recovery.2 b/doc/man/nvme_set_features_err_recovery.2 new file mode 100644 index 0000000..69de02e --- /dev/null +++ b/doc/man/nvme_set_features_err_recovery.2 @@ -0,0 +1,27 @@ +.TH "nvme_set_features_err_recovery" 9 "nvme_set_features_err_recovery" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_err_recovery \- +.SH SYNOPSIS +.B "int" nvme_set_features_err_recovery +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "__u16 tler " "," +.BI "bool dulbe " "," +.BI "bool save " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Namespace ID +.IP "tler" 12 +Time-limited error recovery value +.IP "dulbe" 12 +Deallocated or Unwritten Logical Block Error Enable +.IP "save" 12 +Save value across power states +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_hctm.2 b/doc/man/nvme_set_features_hctm.2 new file mode 100644 index 0000000..6b47711 --- /dev/null +++ b/doc/man/nvme_set_features_hctm.2 @@ -0,0 +1,24 @@ +.TH "nvme_set_features_hctm" 9 "nvme_set_features_hctm" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_hctm \- +.SH SYNOPSIS +.B "int" nvme_set_features_hctm +.BI "(int fd " "," +.BI "__u16 tmt2 " "," +.BI "__u16 tmt1 " "," +.BI "bool save " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "tmt2" 12 +Thermal Management Temperature 2 +.IP "tmt1" 12 +Thermal Management Temperature 1 +.IP "save" 12 +Save value across power states +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_host_behavior.2 b/doc/man/nvme_set_features_host_behavior.2 new file mode 100644 index 0000000..271dbb2 --- /dev/null +++ b/doc/man/nvme_set_features_host_behavior.2 @@ -0,0 +1,18 @@ +.TH "nvme_set_features_host_behavior" 9 "nvme_set_features_host_behavior" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_host_behavior \- +.SH SYNOPSIS +.B "int" nvme_set_features_host_behavior +.BI "(int fd " "," +.BI "bool save " "," +.BI "struct nvme_feat_host_behavior *data " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "save" 12 +Save value across power states +.IP "data" 12 +Pointer to structure nvme_feat_host_behavior +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_host_id.2 b/doc/man/nvme_set_features_host_id.2 new file mode 100644 index 0000000..09de5d5 --- /dev/null +++ b/doc/man/nvme_set_features_host_id.2 @@ -0,0 +1,21 @@ +.TH "nvme_set_features_host_id" 9 "nvme_set_features_host_id" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_host_id \- +.SH SYNOPSIS +.B "int" nvme_set_features_host_id +.BI "(int fd " "," +.BI "bool exhid " "," +.BI "bool save " "," +.BI "__u8 *hostid " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "exhid" 12 +Enable Extended Host Identifier +.IP "save" 12 +Save value across power states +.IP "hostid" 12 +Host ID to set +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_irq_coalesce.2 b/doc/man/nvme_set_features_irq_coalesce.2 new file mode 100644 index 0000000..58d2e3f --- /dev/null +++ b/doc/man/nvme_set_features_irq_coalesce.2 @@ -0,0 +1,24 @@ +.TH "nvme_set_features_irq_coalesce" 9 "nvme_set_features_irq_coalesce" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_irq_coalesce \- +.SH SYNOPSIS +.B "int" nvme_set_features_irq_coalesce +.BI "(int fd " "," +.BI "__u8 thr " "," +.BI "__u8 time " "," +.BI "bool save " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "thr" 12 +Aggregation Threshold +.IP "time" 12 +Aggregation Time +.IP "save" 12 +Save value across power states +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_irq_config.2 b/doc/man/nvme_set_features_irq_config.2 new file mode 100644 index 0000000..ffce575 --- /dev/null +++ b/doc/man/nvme_set_features_irq_config.2 @@ -0,0 +1,24 @@ +.TH "nvme_set_features_irq_config" 9 "nvme_set_features_irq_config" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_irq_config \- +.SH SYNOPSIS +.B "int" nvme_set_features_irq_config +.BI "(int fd " "," +.BI "__u16 iv " "," +.BI "bool cd " "," +.BI "bool save " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "iv" 12 +Interrupt Vector +.IP "cd" 12 +Coalescing Disable +.IP "save" 12 +Save value across power states +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_lba_range.2 b/doc/man/nvme_set_features_lba_range.2 new file mode 100644 index 0000000..94ca62d --- /dev/null +++ b/doc/man/nvme_set_features_lba_range.2 @@ -0,0 +1,27 @@ +.TH "nvme_set_features_lba_range" 9 "nvme_set_features_lba_range" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_lba_range \- +.SH SYNOPSIS +.B "int" nvme_set_features_lba_range +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "__u32 nr_ranges " "," +.BI "bool save " "," +.BI "struct nvme_lba_range_type *data " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Namespace ID +.IP "nr_ranges" 12 +Number of ranges in \fIdata\fP +.IP "save" 12 +Save value across power states +.IP "data" 12 +User address of feature data +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_lba_sts_interval.2 b/doc/man/nvme_set_features_lba_sts_interval.2 new file mode 100644 index 0000000..1507a76 --- /dev/null +++ b/doc/man/nvme_set_features_lba_sts_interval.2 @@ -0,0 +1,24 @@ +.TH "nvme_set_features_lba_sts_interval" 9 "nvme_set_features_lba_sts_interval" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_lba_sts_interval \- +.SH SYNOPSIS +.B "int" nvme_set_features_lba_sts_interval +.BI "(int fd " "," +.BI "__u16 lsiri " "," +.BI "__u16 lsipi " "," +.BI "bool save " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "lsiri" 12 +LBA Status Information Report Interval +.IP "lsipi" 12 +LBA Status Information Poll Interval +.IP "save" 12 +Save value across power states +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_nopsc.2 b/doc/man/nvme_set_features_nopsc.2 new file mode 100644 index 0000000..c3ed464 --- /dev/null +++ b/doc/man/nvme_set_features_nopsc.2 @@ -0,0 +1,21 @@ +.TH "nvme_set_features_nopsc" 9 "nvme_set_features_nopsc" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_nopsc \- +.SH SYNOPSIS +.B "int" nvme_set_features_nopsc +.BI "(int fd " "," +.BI "bool noppme " "," +.BI "bool save " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "noppme" 12 +Non-Operational Power State Permissive Mode Enable +.IP "save" 12 +Save value across power states +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_plm_config.2 b/doc/man/nvme_set_features_plm_config.2 new file mode 100644 index 0000000..3443b6f --- /dev/null +++ b/doc/man/nvme_set_features_plm_config.2 @@ -0,0 +1,27 @@ +.TH "nvme_set_features_plm_config" 9 "nvme_set_features_plm_config" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_plm_config \- +.SH SYNOPSIS +.B "int" nvme_set_features_plm_config +.BI "(int fd " "," +.BI "bool enable " "," +.BI "__u16 nvmsetid " "," +.BI "bool save " "," +.BI "struct nvme_plm_config *data " "," +.BI "__u32*result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "enable" 12 +Predictable Latency Enable +.IP "nvmsetid" 12 +NVM Set Identifier +.IP "save" 12 +Save value across power states +.IP "data" 12 +Pointer to structure nvme_plm_config +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_plm_window.2 b/doc/man/nvme_set_features_plm_window.2 new file mode 100644 index 0000000..66cf86d --- /dev/null +++ b/doc/man/nvme_set_features_plm_window.2 @@ -0,0 +1,24 @@ +.TH "nvme_set_features_plm_window" 9 "nvme_set_features_plm_window" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_plm_window \- +.SH SYNOPSIS +.B "int" nvme_set_features_plm_window +.BI "(int fd " "," +.BI "enum nvme_feat_plm_window_select sel " "," +.BI "__u16 nvmsetid " "," +.BI "bool save " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "sel" 12 +Window Select +.IP "nvmsetid" 12 +NVM Set Identifier +.IP "save" 12 +Save value across power states +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_power_mgmt.2 b/doc/man/nvme_set_features_power_mgmt.2 new file mode 100644 index 0000000..1cce50e --- /dev/null +++ b/doc/man/nvme_set_features_power_mgmt.2 @@ -0,0 +1,24 @@ +.TH "nvme_set_features_power_mgmt" 9 "nvme_set_features_power_mgmt" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_power_mgmt \- +.SH SYNOPSIS +.B "int" nvme_set_features_power_mgmt +.BI "(int fd " "," +.BI "__u8 ps " "," +.BI "__u8 wh " "," +.BI "bool save " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "ps" 12 +Power State +.IP "wh" 12 +Workload Hint +.IP "save" 12 +Save value across power states +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_resv_mask.2 b/doc/man/nvme_set_features_resv_mask.2 new file mode 100644 index 0000000..5804011 --- /dev/null +++ b/doc/man/nvme_set_features_resv_mask.2 @@ -0,0 +1,21 @@ +.TH "nvme_set_features_resv_mask" 9 "nvme_set_features_resv_mask" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_resv_mask \- +.SH SYNOPSIS +.B "int" nvme_set_features_resv_mask +.BI "(int fd " "," +.BI "__u32 mask " "," +.BI "bool save " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "mask" 12 +Reservation Notification Mask Field +.IP "save" 12 +Save value across power states +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_resv_persist.2 b/doc/man/nvme_set_features_resv_persist.2 new file mode 100644 index 0000000..e487d6f --- /dev/null +++ b/doc/man/nvme_set_features_resv_persist.2 @@ -0,0 +1,21 @@ +.TH "nvme_set_features_resv_persist" 9 "nvme_set_features_resv_persist" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_resv_persist \- +.SH SYNOPSIS +.B "int" nvme_set_features_resv_persist +.BI "(int fd " "," +.BI "bool ptpl " "," +.BI "bool save " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "ptpl" 12 +Persist Through Power Loss +.IP "save" 12 +Save value across power states +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_rrl.2 b/doc/man/nvme_set_features_rrl.2 new file mode 100644 index 0000000..d2b264c --- /dev/null +++ b/doc/man/nvme_set_features_rrl.2 @@ -0,0 +1,24 @@ +.TH "nvme_set_features_rrl" 9 "nvme_set_features_rrl" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_rrl \- +.SH SYNOPSIS +.B "int" nvme_set_features_rrl +.BI "(int fd " "," +.BI "__u8 rrl " "," +.BI "__u16 nvmsetid " "," +.BI "bool save " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "rrl" 12 +Read recovery level setting +.IP "nvmsetid" 12 +NVM set id +.IP "save" 12 +Save value across power states +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_sanitize.2 b/doc/man/nvme_set_features_sanitize.2 new file mode 100644 index 0000000..c1fe032 --- /dev/null +++ b/doc/man/nvme_set_features_sanitize.2 @@ -0,0 +1,21 @@ +.TH "nvme_set_features_sanitize" 9 "nvme_set_features_sanitize" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_sanitize \- +.SH SYNOPSIS +.B "int" nvme_set_features_sanitize +.BI "(int fd " "," +.BI "bool nodrm " "," +.BI "bool save " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nodrm" 12 +No-Deallocate Response Mode +.IP "save" 12 +Save value across power states +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_simple.2 b/doc/man/nvme_set_features_simple.2 new file mode 100644 index 0000000..3a1d8de --- /dev/null +++ b/doc/man/nvme_set_features_simple.2 @@ -0,0 +1,24 @@ +.TH "nvme_set_features_simple" 9 "nvme_set_features_simple" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_simple \- Helper functionn for @nvme_set_features() +.SH SYNOPSIS +.B "int" nvme_set_features_simple +.BI "(int fd " "," +.BI "__u8 fid " "," +.BI "__u32 nsid " "," +.BI "__u32 cdw11 " "," +.BI "bool save " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "fid" 12 +Feature identifier +.IP "nsid" 12 +Namespace ID, if applicable +.IP "cdw11" 12 +Value to set the feature to +.IP "save" 12 +Save value across power states +.IP "result" 12 +The command completion result from CQE dword0 diff --git a/doc/man/nvme_set_features_sw_progress.2 b/doc/man/nvme_set_features_sw_progress.2 new file mode 100644 index 0000000..eb48ccd --- /dev/null +++ b/doc/man/nvme_set_features_sw_progress.2 @@ -0,0 +1,21 @@ +.TH "nvme_set_features_sw_progress" 9 "nvme_set_features_sw_progress" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_sw_progress \- +.SH SYNOPSIS +.B "int" nvme_set_features_sw_progress +.BI "(int fd " "," +.BI "__u8 pbslc " "," +.BI "bool save " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "pbslc" 12 +Pre-boot Software Load Count +.IP "save" 12 +Save value across power states +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_temp_thresh.2 b/doc/man/nvme_set_features_temp_thresh.2 new file mode 100644 index 0000000..ae653c1 --- /dev/null +++ b/doc/man/nvme_set_features_temp_thresh.2 @@ -0,0 +1,27 @@ +.TH "nvme_set_features_temp_thresh" 9 "nvme_set_features_temp_thresh" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_temp_thresh \- +.SH SYNOPSIS +.B "int" nvme_set_features_temp_thresh +.BI "(int fd " "," +.BI "__u16 tmpth " "," +.BI "__u8 tmpsel " "," +.BI "enum nvme_feat_tmpthresh_thsel thsel " "," +.BI "bool save " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "tmpth" 12 +Temperature Threshold +.IP "tmpsel" 12 +Threshold Temperature Select +.IP "thsel" 12 +Threshold Type Select +.IP "save" 12 +Save value across power states +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_timestamp.2 b/doc/man/nvme_set_features_timestamp.2 new file mode 100644 index 0000000..f286a0d --- /dev/null +++ b/doc/man/nvme_set_features_timestamp.2 @@ -0,0 +1,18 @@ +.TH "nvme_set_features_timestamp" 9 "nvme_set_features_timestamp" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_timestamp \- +.SH SYNOPSIS +.B "int" nvme_set_features_timestamp +.BI "(int fd " "," +.BI "bool save " "," +.BI "__u64 timestamp " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "save" 12 +Save value across power states +.IP "timestamp" 12 +The current timestamp value to assign to this this feature +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_volatile_wc.2 b/doc/man/nvme_set_features_volatile_wc.2 new file mode 100644 index 0000000..4ec60c8 --- /dev/null +++ b/doc/man/nvme_set_features_volatile_wc.2 @@ -0,0 +1,21 @@ +.TH "nvme_set_features_volatile_wc" 9 "nvme_set_features_volatile_wc" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_volatile_wc \- +.SH SYNOPSIS +.B "int" nvme_set_features_volatile_wc +.BI "(int fd " "," +.BI "bool wce " "," +.BI "bool save " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "wce" 12 +Write cache enable +.IP "save" 12 +Save value across power states +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_write_atomic.2 b/doc/man/nvme_set_features_write_atomic.2 new file mode 100644 index 0000000..5037a0b --- /dev/null +++ b/doc/man/nvme_set_features_write_atomic.2 @@ -0,0 +1,21 @@ +.TH "nvme_set_features_write_atomic" 9 "nvme_set_features_write_atomic" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_write_atomic \- +.SH SYNOPSIS +.B "int" nvme_set_features_write_atomic +.BI "(int fd " "," +.BI "bool dn " "," +.BI "bool save " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "dn" 12 +Disable Normal +.IP "save" 12 +Save value across power states +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_features_write_protect.2 b/doc/man/nvme_set_features_write_protect.2 new file mode 100644 index 0000000..e87dfe1 --- /dev/null +++ b/doc/man/nvme_set_features_write_protect.2 @@ -0,0 +1,21 @@ +.TH "nvme_set_features_write_protect" 9 "nvme_set_features_write_protect" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_features_write_protect \- +.SH SYNOPSIS +.B "int" nvme_set_features_write_protect +.BI "(int fd " "," +.BI "enum nvme_feat_nswpcfg_state state " "," +.BI "bool save " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "state" 12 +Write Protection State +.IP "save" 12 +Save value across power states +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_property.2 b/doc/man/nvme_set_property.2 new file mode 100644 index 0000000..6d484a1 --- /dev/null +++ b/doc/man/nvme_set_property.2 @@ -0,0 +1,15 @@ +.TH "nvme_set_property" 9 "nvme_set_property" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_set_property \- Set controller property +.SH SYNOPSIS +.B "int" nvme_set_property +.BI "(struct nvme_set_property_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_set_property_args\fP argument structure +.SH "DESCRIPTION" +This is an NVMe-over-Fabrics specific command, not applicable to PCIe. These +properties align to the PCI MMIO controller registers. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_set_property_args.2 b/doc/man/nvme_set_property_args.2 new file mode 100644 index 0000000..3d40857 --- /dev/null +++ b/doc/man/nvme_set_property_args.2 @@ -0,0 +1,35 @@ +.TH "libnvme" 9 "struct nvme_set_property_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_set_property_args \- Arguments for NVMe Set Property command +.SH SYNOPSIS +struct nvme_set_property_args { +.br +.BI " __u64 value;" +.br +.BI " __u32 *result;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " int offset;" +.br +.BI " +}; +.br + +.SH Members +.IP "value" 12 +The value to set the property +.IP "result" 12 +The command completion result from CQE dword0 +.IP "args_size" 12 +Size of \fIstruct nvme_set_property_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "offset" 12 +Property offset from the base to set diff --git a/doc/man/nvme_smart_crit.2 b/doc/man/nvme_smart_crit.2 new file mode 100644 index 0000000..9a23b81 --- /dev/null +++ b/doc/man/nvme_smart_crit.2 @@ -0,0 +1,54 @@ +.TH "libnvme" 9 "enum nvme_smart_crit" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_smart_crit \- Critical Warning +.SH SYNOPSIS +enum nvme_smart_crit { +.br +.BI " NVME_SMART_CRIT_SPARE" +, +.br +.br +.BI " NVME_SMART_CRIT_TEMPERATURE" +, +.br +.br +.BI " NVME_SMART_CRIT_DEGRADED" +, +.br +.br +.BI " NVME_SMART_CRIT_MEDIA" +, +.br +.br +.BI " NVME_SMART_CRIT_VOLATILE_MEMORY" +, +.br +.br +.BI " NVME_SMART_CRIT_PMR_RO" + +}; +.SH Constants +.IP "NVME_SMART_CRIT_SPARE" 12 +If set, then the available spare capacity has fallen +below the threshold. +.IP "NVME_SMART_CRIT_TEMPERATURE" 12 +If set, then a temperature is either greater +than or equal to an over temperature threshold; or +less than or equal to an under temperature threshold. +.IP "NVME_SMART_CRIT_DEGRADED" 12 +If set, then the NVM subsystem reliability has +been degraded due to significant media related errors +or any internal error that degrades NVM subsystem +reliability. +.IP "NVME_SMART_CRIT_MEDIA" 12 +If set, then all of the media has been placed in read +only mode. The controller shall not set this bit if +the read-only condition on the media is a result of +a change in the write protection state of a namespace. +.IP "NVME_SMART_CRIT_VOLATILE_MEMORY" 12 +If set, then the volatile memory backup +device has failed. This field is only valid if the +controller has a volatile memory backup solution. +.IP "NVME_SMART_CRIT_PMR_RO" 12 +If set, then the Persistent Memory Region has become +read-only or unreliable. diff --git a/doc/man/nvme_smart_egcw.2 b/doc/man/nvme_smart_egcw.2 new file mode 100644 index 0000000..9bb08a9 --- /dev/null +++ b/doc/man/nvme_smart_egcw.2 @@ -0,0 +1,31 @@ +.TH "libnvme" 9 "enum nvme_smart_egcw" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_smart_egcw \- Endurance Group Critical Warning Summary +.SH SYNOPSIS +enum nvme_smart_egcw { +.br +.BI " NVME_SMART_EGCW_SPARE" +, +.br +.br +.BI " NVME_SMART_EGCW_DEGRADED" +, +.br +.br +.BI " NVME_SMART_EGCW_RO" + +}; +.SH Constants +.IP "NVME_SMART_EGCW_SPARE" 12 +If set, then the available spare capacity of one or +more Endurance Groups has fallen below the threshold. +.IP "NVME_SMART_EGCW_DEGRADED" 12 +If set, then the reliability of one or more +Endurance Groups has been degraded due to significant +media related errors or any internal error that +degrades NVM subsystem reliability. +.IP "NVME_SMART_EGCW_RO" 12 +If set, then the namespaces in one or more Endurance +Groups have been placed in read only mode not as +a result of a change in the write protection state +of a namespace. diff --git a/doc/man/nvme_smart_log.2 b/doc/man/nvme_smart_log.2 new file mode 100644 index 0000000..beac84c --- /dev/null +++ b/doc/man/nvme_smart_log.2 @@ -0,0 +1,235 @@ +.TH "libnvme" 9 "struct nvme_smart_log" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_smart_log \- SMART / Health Information Log (Log Identifier 02h) +.SH SYNOPSIS +struct nvme_smart_log { +.br +.BI " __u8 critical_warning;" +.br +.BI " __u8 temperature[2];" +.br +.BI " __u8 avail_spare;" +.br +.BI " __u8 spare_thresh;" +.br +.BI " __u8 percent_used;" +.br +.BI " __u8 endu_grp_crit_warn_sumry;" +.br +.BI " __u8 rsvd7[25];" +.br +.BI " __u8 data_units_read[16];" +.br +.BI " __u8 data_units_written[16];" +.br +.BI " __u8 host_reads[16];" +.br +.BI " __u8 host_writes[16];" +.br +.BI " __u8 ctrl_busy_time[16];" +.br +.BI " __u8 power_cycles[16];" +.br +.BI " __u8 power_on_hours[16];" +.br +.BI " __u8 unsafe_shutdowns[16];" +.br +.BI " __u8 media_errors[16];" +.br +.BI " __u8 num_err_log_entries[16];" +.br +.BI " __le32 warning_temp_time;" +.br +.BI " __le32 critical_comp_time;" +.br +.BI " __le16 temp_sensor[8];" +.br +.BI " __le32 thm_temp1_trans_count;" +.br +.BI " __le32 thm_temp2_trans_count;" +.br +.BI " __le32 thm_temp1_total_time;" +.br +.BI " __le32 thm_temp2_total_time;" +.br +.BI " __u8 rsvd232[280];" +.br +.BI " +}; +.br + +.SH Members +.IP "critical_warning" 12 +This field indicates critical warnings for the state +of the controller. Critical warnings may result in an +asynchronous event notification to the host. Bits in +this field represent the current associated state and +are not persistent (see \fIenum nvme_smart_crit\fP). +.IP "temperature" 12 +Composite Temperature: Contains a value corresponding +to a temperature in Kelvins that represents the current +composite temperature of the controller and namespace(s) +associated with that controller. The manner in which +this value is computed is implementation specific and +may not represent the actual temperature of any physical +point in the NVM subsystem. Warning and critical +overheating composite temperature threshold values are +reported by the WCTEMP and CCTEMP fields in the Identify +Controller data structure. +.IP "avail_spare" 12 +Available Spare: Contains a normalized percentage (0% +to 100%) of the remaining spare capacity available. +.IP "spare_thresh" 12 +Available Spare Threshold: When the Available Spare +falls below the threshold indicated in this field, an +asynchronous event completion may occur. The value is +indicated as a normalized percentage (0% to 100%). +The values 101 to 255 are reserved. +.IP "percent_used" 12 +Percentage Used: Contains a vendor specific estimate +of the percentage of NVM subsystem life used based on +the actual usage and the manufacturer's prediction of +NVM life. A value of 100 indicates that the estimated +endurance of the NVM in the NVM subsystem has been +consumed, but may not indicate an NVM subsystem failure. +The value is allowed to exceed 100. Percentages greater +than 254 shall be represented as 255. This value shall +be updated once per power-on hour (when the controller +is not in a sleep state). +.IP "endu_grp_crit_warn_sumry" 12 +Endurance Group Critical Warning Summary: This field +indicates critical warnings for the state of Endurance +Groups. Bits in this field represent the current associated +state and are not persistent (see \fIenum nvme_smart_egcw\fP). +.IP "rsvd7" 12 +Reserved +.IP "data_units_read" 12 +Data Units Read: Contains the number of 512 byte data +units the host has read from the controller; this value +does not include metadata. This value is reported in +thousands (i.e., a value of 1 corresponds to 1000 +units of 512 bytes read) and is rounded up (e.g., one +indicates the that number of 512 byte data units read +is from 1 to 1000, three indicates that the number of +512 byte data units read is from 2001 to 3000). When +the LBA size is a value other than 512 bytes, the +controller shall convert the amount of data read to +512 byte units. For the NVM command set, logical blocks +read as part of Compare, Read, and Verify operations +shall be included in this value. A value of 0h in +this field indicates that the number of Data Units Read +is not reported. +.IP "data_units_written" 12 +Data Units Written: Contains the number of 512 byte +data units the host has written to the controller; +this value does not include metadata. This value is +reported in thousands (i.e., a value of 1 corresponds +to 1000 units of 512 bytes written) and is rounded up +(e.g., one indicates that the number of 512 byte data +units written is from 1 to 1,000, three indicates that +the number of 512 byte data units written is from 2001 +to 3000). When the LBA size is a value other than 512 +bytes, the controller shall convert the amount of data +written to 512 byte units. For the NVM command set, +logical blocks written as part of Write operations shall +be included in this value. Write Uncorrectable commands +and Write Zeroes commands shall not impact this value. +A value of 0h in this field indicates that the number +of Data Units Written is not reported. +.IP "host_reads" 12 +Host Read Commands: Contains the number of read commands +completed by the controller. For the NVM command set, +this value is the sum of the number of Compare commands +and the number of Read commands. +.IP "host_writes" 12 +Host Write Commands: Contains the number of write +commands completed by the controller. For the NVM +command set, this is the number of Write commands. +.IP "ctrl_busy_time" 12 +Controller Busy Time: Contains the amount of time the +controller is busy with I/O commands. The controller +is busy when there is a command outstanding to an I/O +Queue (specifically, a command was issued via an I/O +Submission Queue Tail doorbell write and the corresponding +completion queue entry has not been posted yet to the +associated I/O Completion Queue). This value is +reported in minutes. +.IP "power_cycles" 12 +Power Cycles: Contains the number of power cycles. +.IP "power_on_hours" 12 +Power On Hours: Contains the number of power-on hours. +This may not include time that the controller was +powered and in a non-operational power state. +.IP "unsafe_shutdowns" 12 +Unsafe Shutdowns: Contains the number of unsafe +shutdowns. This count is incremented when a Shutdown +Notification (CC.SHN) is not received prior to loss of power. +.IP "media_errors" 12 +Media and Data Integrity Errors: Contains the number +of occurrences where the controller detected an +unrecovered data integrity error. Errors such as +uncorrectable ECC, CRC checksum failure, or LBA tag +mismatch are included in this field. Errors introduced +as a result of a Write Uncorrectable command may or +may not be included in this field. +.IP "num_err_log_entries" 12 +Number of Error Information Log Entries: Contains the +number of Error Information log entries over the life +of the controller. +.IP "warning_temp_time" 12 +Warning Composite Temperature Time: Contains the amount +of time in minutes that the controller is operational +and the Composite Temperature is greater than or equal +to the Warning Composite Temperature Threshold (WCTEMP) +field and less than the Critical Composite Temperature +Threshold (CCTEMP) field in the Identify Controller +data structure. If the value of the WCTEMP or CCTEMP +field is 0h, then this field is always cleared to 0h +regardless of the Composite Temperature value. +.IP "critical_comp_time" 12 +Critical Composite Temperature Time: Contains the amount +of time in minutes that the controller is operational +and the Composite Temperature is greater than or equal +to the Critical Composite Temperature Threshold (CCTEMP) +field in the Identify Controller data structure. If +the value of the CCTEMP field is 0h, then this field +is always cleared to 0h regardless of the Composite +Temperature value. +.IP "temp_sensor" 12 +Temperature Sensor 1-8: Contains the current temperature +in degrees Kelvin reported by temperature sensors 1-8. +The physical point in the NVM subsystem whose temperature +is reported by the temperature sensor and the temperature +accuracy is implementation specific. An implementation +that does not implement the temperature sensor reports +a value of 0h. +.IP "thm_temp1_trans_count" 12 +Thermal Management Temperature 1 Transition Count: +Contains the number of times the controller transitioned +to lower power active power states or performed vendor +specific thermal management actions while minimizing +the impact on performance in order to attempt to reduce +the Composite Temperature because of the host controlled +thermal management feature (i.e., the Composite +Temperature rose above the Thermal Management +Temperature 1). This counter shall not wrap once the +value FFFFFFFFh is reached. A value of 0h, indicates +that this transition has never occurred or this field +is not implemented. +.IP "thm_temp2_trans_count" 12 +Thermal Management Temperature 2 Transition Count +.IP "thm_temp1_total_time" 12 +Total Time For Thermal Management Temperature 1: +Contains the number of seconds that the controller +had transitioned to lower power active power states or +performed vendor specific thermal management actions +while minimizing the impact on performance in order to +attempt to reduce the Composite Temperature because of +the host controlled thermal management feature. This +counter shall not wrap once the value FFFFFFFFh is +reached. A value of 0h, indicates that this transition +has never occurred or this field is not implemented. +.IP "thm_temp2_total_time" 12 +Total Time For Thermal Management Temperature 2 +.IP "rsvd232" 12 +Reserved diff --git a/doc/man/nvme_st_code.2 b/doc/man/nvme_st_code.2 new file mode 100644 index 0000000..83b3aaa --- /dev/null +++ b/doc/man/nvme_st_code.2 @@ -0,0 +1,37 @@ +.TH "libnvme" 9 "enum nvme_st_code" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_st_code \- Self-test Code value +.SH SYNOPSIS +enum nvme_st_code { +.br +.BI " NVME_ST_CODE_RESERVED" +, +.br +.br +.BI " NVME_ST_CODE_SHORT" +, +.br +.br +.BI " NVME_ST_CODE_EXTENDED" +, +.br +.br +.BI " NVME_ST_CODE_VS" +, +.br +.br +.BI " NVME_ST_CODE_SHIFT" + +}; +.SH Constants +.IP "NVME_ST_CODE_RESERVED" 12 +Reserved. +.IP "NVME_ST_CODE_SHORT" 12 +Short device self-test operation. +.IP "NVME_ST_CODE_EXTENDED" 12 +Extended device self-test operation. +.IP "NVME_ST_CODE_VS" 12 +Vendor specific. +.IP "NVME_ST_CODE_SHIFT" 12 +Shift amount to get the code value from the +\fIstruct nvme_st_result\fP.dsts field. diff --git a/doc/man/nvme_st_curr_op.2 b/doc/man/nvme_st_curr_op.2 new file mode 100644 index 0000000..1148499 --- /dev/null +++ b/doc/man/nvme_st_curr_op.2 @@ -0,0 +1,50 @@ +.TH "libnvme" 9 "enum nvme_st_curr_op" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_st_curr_op \- Current Device Self-Test Operation +.SH SYNOPSIS +enum nvme_st_curr_op { +.br +.BI " NVME_ST_CURR_OP_NOT_RUNNING" +, +.br +.br +.BI " NVME_ST_CURR_OP_SHORT" +, +.br +.br +.BI " NVME_ST_CURR_OP_EXTENDED" +, +.br +.br +.BI " NVME_ST_CURR_OP_VS" +, +.br +.br +.BI " NVME_ST_CURR_OP_RESERVED" +, +.br +.br +.BI " NVME_ST_CURR_OP_MASK" +, +.br +.br +.BI " NVME_ST_CURR_OP_CMPL_MASK" + +}; +.SH Constants +.IP "NVME_ST_CURR_OP_NOT_RUNNING" 12 +No device self-test operation in progress. +.IP "NVME_ST_CURR_OP_SHORT" 12 +Short device self-test operation in progress. +.IP "NVME_ST_CURR_OP_EXTENDED" 12 +Extended device self-test operation in progress. +.IP "NVME_ST_CURR_OP_VS" 12 +Vendor specific. +.IP "NVME_ST_CURR_OP_RESERVED" 12 +Reserved. +.IP "NVME_ST_CURR_OP_MASK" 12 +Mask to get the current operation value from the +\fIstruct nvme_self_test_log\fP.current_operation field. +.IP "NVME_ST_CURR_OP_CMPL_MASK" 12 +Mask to get the current operation completion value +from the \fIstruct nvme_self_test_log\fP.completion field. diff --git a/doc/man/nvme_st_result.2 b/doc/man/nvme_st_result.2 new file mode 100644 index 0000000..e8b2b34 --- /dev/null +++ b/doc/man/nvme_st_result.2 @@ -0,0 +1,77 @@ +.TH "libnvme" 9 "struct nvme_st_result" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_st_result \- Self-test Result +.SH SYNOPSIS +struct nvme_st_result { +.br +.BI " __u8 dsts;" +.br +.BI " __u8 seg;" +.br +.BI " __u8 vdi;" +.br +.BI " __u8 rsvd;" +.br +.BI " __le64 poh;" +.br +.BI " __le32 nsid;" +.br +.BI " __le64 flba;" +.br +.BI " __u8 sct;" +.br +.BI " __u8 sc;" +.br +.BI " __u8 vs[2];" +.br +.BI " +}; +.br + +.SH Members +.IP "dsts" 12 +Device Self-test Status: Indicates the device self-test code and the +status of the operation (see \fIenum nvme_status_result\fP and \fIenum nvme_st_code\fP). +.IP "seg" 12 +Segment Number: Iindicates the segment number where the first self-test +failure occurred. If Device Self-test Status (\fIdsts\fP) is not set to +#NVME_ST_RESULT_KNOWN_SEG_FAIL, then this field should be ignored. +.IP "vdi" 12 +Valid Diagnostic Information: Indicates the diagnostic failure +information that is reported. See \fIenum nvme_st_valid_diag_info\fP. +.IP "rsvd" 12 +Reserved +.IP "poh" 12 +Power On Hours (POH): Indicates the number of power-on hours at the +time the device self-test operation was completed or aborted. This +does not include time that the controller was powered and in a low +power state condition. +.IP "nsid" 12 +Namespace Identifier (NSID): Indicates the namespace that the Failing +LBA occurred on. Valid only when the NSID Valid bit +(#NVME_ST_VALID_DIAG_INFO_NSID) is set in the Valid Diagnostic +Information (\fIvdi\fP) field. +.IP "flba" 12 +Failing LBA: indicates the LBA of the logical block that caused the +test to fail. If the device encountered more than one failed logical +block during the test, then this field only indicates one of those +failed logical blocks. Valid only when the NSID Valid bit +(#NVME_ST_VALID_DIAG_INFO_FLBA) is set in the Valid Diagnostic +Information (\fIvdi\fP) field. +.IP "sct" 12 +Status Code Type: This field may contain additional information related +to errors or conditions. Bits 2:0 may contain additional information +relating to errors or conditions that occurred during the device +self-test operation represented in the same format used in the Status +Code Type field of the completion queue entry (refer to \fIenum nvme_status_field\fP). +Valid only when the NSID Valid bit (#NVME_ST_VALID_DIAG_INFO_SCT) is +set in the Valid Diagnostic Information (\fIvdi\fP) field. +.IP "sc" 12 +Status Code: This field may contain additional information relating +to errors or conditions that occurred during the device self-test +operation represented in the same format used in the Status Code field +of the completion queue entry. Valid only when the SCT Valid bit +(#NVME_ST_VALID_DIAG_INFO_SC) is set in the Valid Diagnostic +Information (\fIvdi\fP) field. +.IP "vs" 12 +Vendor Specific. diff --git a/doc/man/nvme_st_valid_diag_info.2 b/doc/man/nvme_st_valid_diag_info.2 new file mode 100644 index 0000000..09d123a --- /dev/null +++ b/doc/man/nvme_st_valid_diag_info.2 @@ -0,0 +1,34 @@ +.TH "libnvme" 9 "enum nvme_st_valid_diag_info" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_st_valid_diag_info \- Valid Diagnostic Information +.SH SYNOPSIS +enum nvme_st_valid_diag_info { +.br +.BI " NVME_ST_VALID_DIAG_INFO_NSID" +, +.br +.br +.BI " NVME_ST_VALID_DIAG_INFO_FLBA" +, +.br +.br +.BI " NVME_ST_VALID_DIAG_INFO_SCT" +, +.br +.br +.BI " NVME_ST_VALID_DIAG_INFO_SC" + +}; +.SH Constants +.IP "NVME_ST_VALID_DIAG_INFO_NSID" 12 +NSID Valid: if set, then the contents of +the Namespace Identifier field are valid. +.IP "NVME_ST_VALID_DIAG_INFO_FLBA" 12 +FLBA Valid: if set, then the contents of +the Failing LBA field are valid. +.IP "NVME_ST_VALID_DIAG_INFO_SCT" 12 +SCT Valid: if set, then the contents of +the Status Code Type field are valid. +.IP "NVME_ST_VALID_DIAG_INFO_SC" 12 +SC Valid: if set, then the contents of +the Status Code field are valid. diff --git a/doc/man/nvme_status_code.2 b/doc/man/nvme_status_code.2 new file mode 100644 index 0000000..2087a4f --- /dev/null +++ b/doc/man/nvme_status_code.2 @@ -0,0 +1,11 @@ +.TH "nvme_status_code" 9 "nvme_status_code" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_status_code \- Returns the NVMe Status Code +.SH SYNOPSIS +.B "__u16" nvme_status_code +.BI "(__u16 status_field " ");" +.SH ARGUMENTS +.IP "status_field" 12 +The NVMe Completion Queue Entry's Status Field +.SH "DESCRIPTION" +See \fIenum nvme_status_field\fP diff --git a/doc/man/nvme_status_code_type.2 b/doc/man/nvme_status_code_type.2 new file mode 100644 index 0000000..39fb999 --- /dev/null +++ b/doc/man/nvme_status_code_type.2 @@ -0,0 +1,11 @@ +.TH "nvme_status_code_type" 9 "nvme_status_code_type" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_status_code_type \- Returns the NVMe Status Code Type +.SH SYNOPSIS +.B "__u16" nvme_status_code_type +.BI "(__u16 status_field " ");" +.SH ARGUMENTS +.IP "status_field" 12 +The NVMe Completion Queue Entry's Status Field +.SH "DESCRIPTION" +See \fIenum nvme_status_field\fP diff --git a/doc/man/nvme_status_field.2 b/doc/man/nvme_status_field.2 new file mode 100644 index 0000000..d39a561 --- /dev/null +++ b/doc/man/nvme_status_field.2 @@ -0,0 +1,1153 @@ +.TH "libnvme" 9 "enum nvme_status_field" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_status_field \- Defines all parts of the nvme status field: status code, status code type, and additional flags. +.SH SYNOPSIS +enum nvme_status_field { +.br +.BI " NVME_SCT_GENERIC" +, +.br +.br +.BI " NVME_SCT_CMD_SPECIFIC" +, +.br +.br +.BI " NVME_SCT_MEDIA" +, +.br +.br +.BI " NVME_SCT_PATH" +, +.br +.br +.BI " NVME_SCT_VS" +, +.br +.br +.BI " NVME_SCT_MASK" +, +.br +.br +.BI " NVME_SCT_SHIFT" +, +.br +.br +.BI " NVME_SC_MASK" +, +.br +.br +.BI " NVME_SC_SHIFT" +, +.br +.br +.BI " NVME_SC_SUCCESS" +, +.br +.br +.BI " NVME_SC_INVALID_OPCODE" +, +.br +.br +.BI " NVME_SC_INVALID_FIELD" +, +.br +.br +.BI " NVME_SC_CMDID_CONFLICT" +, +.br +.br +.BI " NVME_SC_DATA_XFER_ERROR" +, +.br +.br +.BI " NVME_SC_POWER_LOSS" +, +.br +.br +.BI " NVME_SC_INTERNAL" +, +.br +.br +.BI " NVME_SC_ABORT_REQ" +, +.br +.br +.BI " NVME_SC_ABORT_QUEUE" +, +.br +.br +.BI " NVME_SC_FUSED_FAIL" +, +.br +.br +.BI " NVME_SC_FUSED_MISSING" +, +.br +.br +.BI " NVME_SC_INVALID_NS" +, +.br +.br +.BI " NVME_SC_CMD_SEQ_ERROR" +, +.br +.br +.BI " NVME_SC_SGL_INVALID_LAST" +, +.br +.br +.BI " NVME_SC_SGL_INVALID_COUNT" +, +.br +.br +.BI " NVME_SC_SGL_INVALID_DATA" +, +.br +.br +.BI " NVME_SC_SGL_INVALID_METADATA" +, +.br +.br +.BI " NVME_SC_SGL_INVALID_TYPE" +, +.br +.br +.BI " NVME_SC_CMB_INVALID_USE" +, +.br +.br +.BI " NVME_SC_PRP_INVALID_OFFSET" +, +.br +.br +.BI " NVME_SC_AWU_EXCEEDED" +, +.br +.br +.BI " NVME_SC_OP_DENIED" +, +.br +.br +.BI " NVME_SC_SGL_INVALID_OFFSET" +, +.br +.br +.BI " NVME_SC_HOSTID_FORMAT" +, +.br +.br +.BI " NVME_SC_KAT_EXPIRED" +, +.br +.br +.BI " NVME_SC_KAT_INVALID" +, +.br +.br +.BI " NVME_SC_CMD_ABORTED_PREMEPT" +, +.br +.br +.BI " NVME_SC_SANITIZE_FAILED" +, +.br +.br +.BI " NVME_SC_SANITIZE_IN_PROGRESS" +, +.br +.br +.BI " NVME_SC_SGL_INVALID_GRANULARITY" +, +.br +.br +.BI " NVME_SC_CMD_IN_CMBQ_NOT_SUPP" +, +.br +.br +.BI " NVME_SC_NS_WRITE_PROTECTED" +, +.br +.br +.BI " NVME_SC_CMD_INTERRUPTED" +, +.br +.br +.BI " NVME_SC_TRAN_TPORT_ERROR" +, +.br +.br +.BI " NVME_SC_PROHIBITED_BY_CMD_AND_FEAT" +, +.br +.br +.BI " NVME_SC_ADMIN_CMD_MEDIA_NOT_READY" +, +.br +.br +.BI " NVME_SC_LBA_RANGE" +, +.br +.br +.BI " NVME_SC_CAP_EXCEEDED" +, +.br +.br +.BI " NVME_SC_NS_NOT_READY" +, +.br +.br +.BI " NVME_SC_RESERVATION_CONFLICT" +, +.br +.br +.BI " NVME_SC_FORMAT_IN_PROGRESS" +, +.br +.br +.BI " NVME_SC_CQ_INVALID" +, +.br +.br +.BI " NVME_SC_QID_INVALID" +, +.br +.br +.BI " NVME_SC_QUEUE_SIZE" +, +.br +.br +.BI " NVME_SC_ABORT_LIMIT" +, +.br +.br +.BI " NVME_SC_ABORT_MISSING" +, +.br +.br +.BI " NVME_SC_ASYNC_LIMIT" +, +.br +.br +.BI " NVME_SC_FIRMWARE_SLOT" +, +.br +.br +.BI " NVME_SC_FIRMWARE_IMAGE" +, +.br +.br +.BI " NVME_SC_INVALID_VECTOR" +, +.br +.br +.BI " NVME_SC_INVALID_LOG_PAGE" +, +.br +.br +.BI " NVME_SC_INVALID_FORMAT" +, +.br +.br +.BI " NVME_SC_FW_NEEDS_CONV_RESET" +, +.br +.br +.BI " NVME_SC_INVALID_QUEUE" +, +.br +.br +.BI " NVME_SC_FEATURE_NOT_SAVEABLE" +, +.br +.br +.BI " NVME_SC_FEATURE_NOT_CHANGEABLE" +, +.br +.br +.BI " NVME_SC_FEATURE_NOT_PER_NS" +, +.br +.br +.BI " NVME_SC_FW_NEEDS_SUBSYS_RESET" +, +.br +.br +.BI " NVME_SC_FW_NEEDS_RESET" +, +.br +.br +.BI " NVME_SC_FW_NEEDS_MAX_TIME" +, +.br +.br +.BI " NVME_SC_FW_ACTIVATE_PROHIBITED" +, +.br +.br +.BI " NVME_SC_OVERLAPPING_RANGE" +, +.br +.br +.BI " NVME_SC_NS_INSUFFICIENT_CAP" +, +.br +.br +.BI " NVME_SC_NS_ID_UNAVAILABLE" +, +.br +.br +.BI " NVME_SC_NS_ALREADY_ATTACHED" +, +.br +.br +.BI " NVME_SC_NS_IS_PRIVATE" +, +.br +.br +.BI " NVME_SC_NS_NOT_ATTACHED" +, +.br +.br +.BI " NVME_SC_THIN_PROV_NOT_SUPP" +, +.br +.br +.BI " NVME_SC_CTRL_LIST_INVALID" +, +.br +.br +.BI " NVME_SC_SELF_TEST_IN_PROGRESS" +, +.br +.br +.BI " NVME_SC_BP_WRITE_PROHIBITED" +, +.br +.br +.BI " NVME_SC_INVALID_CTRL_ID" +, +.br +.br +.BI " NVME_SC_INVALID_SEC_CTRL_STATE" +, +.br +.br +.BI " NVME_SC_INVALID_CTRL_RESOURCES" +, +.br +.br +.BI " NVME_SC_INVALID_RESOURCE_ID" +, +.br +.br +.BI " NVME_SC_PMR_SAN_PROHIBITED" +, +.br +.br +.BI " NVME_SC_ANA_GROUP_ID_INVALID" +, +.br +.br +.BI " NVME_SC_ANA_ATTACH_FAILED" +, +.br +.br +.BI " NVME_SC_INSUFFICIENT_CAP" +, +.br +.br +.BI " NVME_SC_NS_ATTACHMENT_LIMIT_EXCEEDED" +, +.br +.br +.BI " NVME_SC_PROHIBIT_CMD_EXEC_NOT_SUPPORTED" +, +.br +.br +.BI " NVME_SC_IOCS_NOT_SUPPORTED" +, +.br +.br +.BI " NVME_SC_IOCS_NOT_ENABLED" +, +.br +.br +.BI " NVME_SC_IOCS_COMBINATION_REJECTED" +, +.br +.br +.BI " NVME_SC_INVALID_IOCS" +, +.br +.br +.BI " NVME_SC_ID_UNAVAILABLE" +, +.br +.br +.BI " NVME_SC_INVALID_DISCOVERY_INFO" +, +.br +.br +.BI " NVME_SC_ZONING_DATA_STRUCT_LOCKED" +, +.br +.br +.BI " NVME_SC_ZONING_DATA_STRUCT_NOTFND" +, +.br +.br +.BI " NVME_SC_INSUFFICIENT_DISC_RES" +, +.br +.br +.BI " NVME_SC_REQSTD_FUNCTION_DISABLED" +, +.br +.br +.BI " NVME_SC_ZONEGRP_ORIGINATOR_INVLD" +, +.br +.br +.BI " NVME_SC_BAD_ATTRIBUTES" +, +.br +.br +.BI " NVME_SC_INVALID_PI" +, +.br +.br +.BI " NVME_SC_READ_ONLY" +, +.br +.br +.BI " NVME_SC_CMD_SIZE_LIMIT_EXCEEDED" +, +.br +.br +.BI " NVME_SC_CONNECT_FORMAT" +, +.br +.br +.BI " NVME_SC_CONNECT_CTRL_BUSY" +, +.br +.br +.BI " NVME_SC_CONNECT_INVALID_PARAM" +, +.br +.br +.BI " NVME_SC_CONNECT_RESTART_DISC" +, +.br +.br +.BI " NVME_SC_CONNECT_INVALID_HOST" +, +.br +.br +.BI " NVME_SC_DISCONNECT_INVALID_QTYPE" +, +.br +.br +.BI " NVME_SC_DISCOVERY_RESTART" +, +.br +.br +.BI " NVME_SC_AUTH_REQUIRED" +, +.br +.br +.BI " NVME_SC_ZNS_INVALID_OP_REQUEST" +, +.br +.br +.BI " NVME_SC_ZNS_ZRWA_RESOURCES_UNAVAILABLE" +, +.br +.br +.BI " NVME_SC_ZNS_BOUNDARY_ERROR" +, +.br +.br +.BI " NVME_SC_ZNS_FULL" +, +.br +.br +.BI " NVME_SC_ZNS_READ_ONLY" +, +.br +.br +.BI " NVME_SC_ZNS_OFFLINE" +, +.br +.br +.BI " NVME_SC_ZNS_INVALID_WRITE" +, +.br +.br +.BI " NVME_SC_ZNS_TOO_MANY_ACTIVE" +, +.br +.br +.BI " NVME_SC_ZNS_TOO_MANY_OPENS" +, +.br +.br +.BI " NVME_SC_ZNS_INVAL_TRANSITION" +, +.br +.br +.BI " NVME_SC_WRITE_FAULT" +, +.br +.br +.BI " NVME_SC_READ_ERROR" +, +.br +.br +.BI " NVME_SC_GUARD_CHECK" +, +.br +.br +.BI " NVME_SC_APPTAG_CHECK" +, +.br +.br +.BI " NVME_SC_REFTAG_CHECK" +, +.br +.br +.BI " NVME_SC_COMPARE_FAILED" +, +.br +.br +.BI " NVME_SC_ACCESS_DENIED" +, +.br +.br +.BI " NVME_SC_UNWRITTEN_BLOCK" +, +.br +.br +.BI " NVME_SC_STORAGE_TAG_CHECK" +, +.br +.br +.BI " NVME_SC_ANA_INTERNAL_PATH_ERROR" +, +.br +.br +.BI " NVME_SC_ANA_PERSISTENT_LOSS" +, +.br +.br +.BI " NVME_SC_ANA_INACCESSIBLE" +, +.br +.br +.BI " NVME_SC_ANA_TRANSITION" +, +.br +.br +.BI " NVME_SC_CTRL_PATH_ERROR" +, +.br +.br +.BI " NVME_SC_HOST_PATH_ERROR" +, +.br +.br +.BI " NVME_SC_CMD_ABORTED_BY_HOST" +, +.br +.br +.BI " NVME_SC_CRD" +, +.br +.br +.BI " NVME_SC_MORE" +, +.br +.br +.BI " NVME_SC_DNR" + +}; +.SH Constants +.IP "NVME_SCT_GENERIC" 12 +Generic errors applicable to multiple opcodes +.IP "NVME_SCT_CMD_SPECIFIC" 12 +Errors associated to a specific opcode +.IP "NVME_SCT_MEDIA" 12 +Errors associated with media and data integrity +.IP "NVME_SCT_PATH" 12 +Errors associated with the paths connection +.IP "NVME_SCT_VS" 12 +Vendor specific errors +.IP "NVME_SCT_MASK" 12 +Mask to get the value of the Status Code Type +.IP "NVME_SCT_SHIFT" 12 +-- undescribed -- +.IP "NVME_SC_MASK" 12 +Mask to get the value of the status code. +.IP "NVME_SC_SHIFT" 12 +-- undescribed -- +.IP "NVME_SC_SUCCESS" 12 +Successful Completion: The command +completed without error. +.IP "NVME_SC_INVALID_OPCODE" 12 +Invalid Command Opcode: A reserved coded +value or an unsupported value in the +command opcode field. +.IP "NVME_SC_INVALID_FIELD" 12 +Invalid Field in Command: A reserved +coded value or an unsupported value in a +defined field. +.IP "NVME_SC_CMDID_CONFLICT" 12 +Command ID Conflict: The command +identifier is already in use. +.IP "NVME_SC_DATA_XFER_ERROR" 12 +Data Transfer Error: Transferring the +data or metadata associated with a +command experienced an error. +.IP "NVME_SC_POWER_LOSS" 12 +Commands Aborted due to Power Loss +Notification: Indicates that the command +was aborted due to a power loss +notification. +.IP "NVME_SC_INTERNAL" 12 +Internal Error: The command was not +completed successfully due to an internal error. +.IP "NVME_SC_ABORT_REQ" 12 +Command Abort Requested: The command was +aborted due to an Abort command being +received that specified the Submission +Queue Identifier and Command Identifier +of this command. +.IP "NVME_SC_ABORT_QUEUE" 12 +Command Aborted due to SQ Deletion: The +command was aborted due to a Delete I/O +Submission Queue request received for the +Submission Queue to which the command was +submitted. +.IP "NVME_SC_FUSED_FAIL" 12 +Command Aborted due to Failed Fused Command: +The command was aborted due to the other +command in a fused operation failing. +.IP "NVME_SC_FUSED_MISSING" 12 +Aborted due to Missing Fused Command: The +fused command was aborted due to the +adjacent submission queue entry not +containing a fused command that is the +other command. +.IP "NVME_SC_INVALID_NS" 12 +Invalid Namespace or Format: The +namespace or the format of that namespace +is invalid. +.IP "NVME_SC_CMD_SEQ_ERROR" 12 +Command Sequence Error: The command was +aborted due to a protocol violation in a +multi-command sequence. +.IP "NVME_SC_SGL_INVALID_LAST" 12 +Invalid SGL Segment Descriptor: The +command includes an invalid SGL Last +Segment or SGL Segment descriptor. +.IP "NVME_SC_SGL_INVALID_COUNT" 12 +Invalid Number of SGL Descriptors: There +is an SGL Last Segment descriptor or an +SGL Segment descriptor in a location +other than the last descriptor of a +segment based on the length indicated. +.IP "NVME_SC_SGL_INVALID_DATA" 12 +Data SGL Length Invalid: This may occur +if the length of a Data SGL is too short. +This may occur if the length of a Data +SGL is too long and the controller does +not support SGL transfers longer than the +amount of data to be transferred as +indicated in the SGL Support field of the +Identify Controller data structure. +.IP "NVME_SC_SGL_INVALID_METADATA" 12 +Metadata SGL Length Invalid: This may +occur if the length of a Metadata SGL is +too short. This may occur if the length +of a Metadata SGL is too long and the +controller does not support SGL transfers +longer than the amount of data to be +transferred as indicated in the SGL +Support field of the Identify Controller +data structure. +.IP "NVME_SC_SGL_INVALID_TYPE" 12 +SGL Descriptor Type Invalid: The type of +an SGL Descriptor is a type that is not +supported by the controller. +.IP "NVME_SC_CMB_INVALID_USE" 12 +Invalid Use of Controller Memory Buffer: +The attempted use of the Controller +Memory Buffer is not supported by the +controller. +.IP "NVME_SC_PRP_INVALID_OFFSET" 12 +PRP Offset Invalid: The Offset field for +a PRP entry is invalid. +.IP "NVME_SC_AWU_EXCEEDED" 12 +Atomic Write Unit Exceeded: The length +specified exceeds the atomic write unit size. +.IP "NVME_SC_OP_DENIED" 12 +Operation Denied: The command was denied +due to lack of access rights. Refer to +the appropriate security specification. +.IP "NVME_SC_SGL_INVALID_OFFSET" 12 +SGL Offset Invalid: The offset specified +in a descriptor is invalid. This may +occur when using capsules for data +transfers in NVMe over Fabrics +implementations and an invalid offset in +the capsule is specified. +.IP "NVME_SC_HOSTID_FORMAT" 12 +Host Identifier Inconsistent Format: The +NVM subsystem detected the simultaneous +use of 64- bit and 128-bit Host +Identifier values on different +controllers. +.IP "NVME_SC_KAT_EXPIRED" 12 +Keep Alive Timer Expired: The Keep Alive +Timer expired. +.IP "NVME_SC_KAT_INVALID" 12 +Keep Alive Timeout Invalid: The Keep +Alive Timeout value specified is invalid. +.IP "NVME_SC_CMD_ABORTED_PREMEPT" 12 +Command Aborted due to Preempt and Abort: +The command was aborted due to a +Reservation Acquire command. +.IP "NVME_SC_SANITIZE_FAILED" 12 +Sanitize Failed: The most recent sanitize +operation failed and no recovery action +has been successfully completed. +.IP "NVME_SC_SANITIZE_IN_PROGRESS" 12 +Sanitize In Progress: The requested +function (e.g., command) is prohibited +while a sanitize operation is in +progress. +.IP "NVME_SC_SGL_INVALID_GRANULARITY" 12 +SGL Data Block Granularity Invalid: The +Address alignment or Length granularity +for an SGL Data Block descriptor is +invalid. +.IP "NVME_SC_CMD_IN_CMBQ_NOT_SUPP" 12 +Command Not Supported for Queue in CMB: +The implementation does not support +submission of the command to a Submission +Queue in the Controller Memory Buffer or +command completion to a Completion Queue +in the Controller Memory Buffer. +.IP "NVME_SC_NS_WRITE_PROTECTED" 12 +Namespace is Write Protected: The command +is prohibited while the namespace is +write protected as a result of a change +in the namespace write protection state +as defined by the Namespace Write +Protection State Machine. +.IP "NVME_SC_CMD_INTERRUPTED" 12 +Command Interrupted: Command processing +was interrupted and the controller is +unable to successfully complete the +command. The host should retry the +command. +.IP "NVME_SC_TRAN_TPORT_ERROR" 12 +Transient Transport Error: A transient +transport error was detected. If the +command is retried on the same +controller, the command is likely to +succeed. A command that fails with a +transient transport error four or more +times should be treated as a persistent +transport error that is not likely to +succeed if retried on the same +controller. +.IP "NVME_SC_PROHIBITED_BY_CMD_AND_FEAT" 12 +Command Prohibited by Command and Feature +Lockdown: The command was aborted due to +command execution being prohibited by +the Command and Feature Lockdown. +.IP "NVME_SC_ADMIN_CMD_MEDIA_NOT_READY" 12 +Admin Command Media Not Ready: The Admin +command requires access to media and +the media is not ready. +.IP "NVME_SC_LBA_RANGE" 12 +LBA Out of Range: The command references +an LBA that exceeds the size of the namespace. +.IP "NVME_SC_CAP_EXCEEDED" 12 +Capacity Exceeded: Execution of the +command has caused the capacity of the +namespace to be exceeded. +.IP "NVME_SC_NS_NOT_READY" 12 +Namespace Not Ready: The namespace is not +ready to be accessed as a result of a +condition other than a condition that is +reported as an Asymmetric Namespace +Access condition. +.IP "NVME_SC_RESERVATION_CONFLICT" 12 +Reservation Conflict: The command was +aborted due to a conflict with a +reservation held on the accessed +namespace. +.IP "NVME_SC_FORMAT_IN_PROGRESS" 12 +Format In Progress: A Format NVM command +is in progress on the namespace. +.IP "NVME_SC_CQ_INVALID" 12 +Completion Queue Invalid: The Completion +Queue identifier specified in the command +does not exist. +.IP "NVME_SC_QID_INVALID" 12 +Invalid Queue Identifier: The creation of +the I/O Completion Queue failed due to an +invalid queue identifier specified as +part of the command. An invalid queue +identifier is one that is currently in +use or one that is outside the range +supported by the controller. +.IP "NVME_SC_QUEUE_SIZE" 12 +Invalid Queue Size: The host attempted to +create an I/O Completion Queue with an +invalid number of entries. +.IP "NVME_SC_ABORT_LIMIT" 12 +Abort Command Limit Exceeded: The number +of concurrently outstanding Abort commands +has exceeded the limit indicated in the +Identify Controller data structure. +.IP "NVME_SC_ABORT_MISSING" 12 +Abort Command is missing: The abort +command is missing. +.IP "NVME_SC_ASYNC_LIMIT" 12 +Asynchronous Event Request Limit +Exceeded: The number of concurrently +outstanding Asynchronous Event Request +commands has been exceeded. +.IP "NVME_SC_FIRMWARE_SLOT" 12 +Invalid Firmware Slot: The firmware slot +indicated is invalid or read only. This +error is indicated if the firmware slot +exceeds the number supported. +.IP "NVME_SC_FIRMWARE_IMAGE" 12 +Invalid Firmware Image: The firmware +image specified for activation is invalid +and not loaded by the controller. +.IP "NVME_SC_INVALID_VECTOR" 12 +Invalid Interrupt Vector: The creation of +the I/O Completion Queue failed due to an +invalid interrupt vector specified as +part of the command. +.IP "NVME_SC_INVALID_LOG_PAGE" 12 +Invalid Log Page: The log page indicated +is invalid. This error condition is also +returned if a reserved log page is +requested. +.IP "NVME_SC_INVALID_FORMAT" 12 +Invalid Format: The LBA Format specified +is not supported. +.IP "NVME_SC_FW_NEEDS_CONV_RESET" 12 +Firmware Activation Requires Conventional Reset: +The firmware commit was successful, +however, activation of the firmware image +requires a conventional reset. +.IP "NVME_SC_INVALID_QUEUE" 12 +Invalid Queue Deletion: Invalid I/O +Completion Queue specified to delete. +.IP "NVME_SC_FEATURE_NOT_SAVEABLE" 12 +Feature Identifier Not Saveable: The +Feature Identifier specified does not +support a saveable value. +.IP "NVME_SC_FEATURE_NOT_CHANGEABLE" 12 +Feature Not Changeable: The Feature +Identifier is not able to be changed. +.IP "NVME_SC_FEATURE_NOT_PER_NS" 12 +Feature Not Namespace Specific: The +Feature Identifier specified is not +namespace specific. The Feature +Identifier settings apply across all +namespaces. +.IP "NVME_SC_FW_NEEDS_SUBSYS_RESET" 12 +Firmware Activation Requires NVM +Subsystem Reset: The firmware commit was +successful, however, activation of the +firmware image requires an NVM Subsystem. +.IP "NVME_SC_FW_NEEDS_RESET" 12 +Firmware Activation Requires Controller +Level Reset: The firmware commit was +successful; however, the image specified +does not support being activated without +a reset. +.IP "NVME_SC_FW_NEEDS_MAX_TIME" 12 +Firmware Activation Requires Maximum Time +Violation: The image specified if +activated immediately would exceed the +Maximum Time for Firmware Activation +(MTFA) value reported in Identify +Controller. +.IP "NVME_SC_FW_ACTIVATE_PROHIBITED" 12 +Firmware Activation Prohibited: The image +specified is being prohibited from +activation by the controller for vendor +specific reasons. +.IP "NVME_SC_OVERLAPPING_RANGE" 12 +Overlapping Range: The downloaded +firmware image has overlapping ranges. +.IP "NVME_SC_NS_INSUFFICIENT_CAP" 12 +Namespace Insufficient Capacity: Creating +the namespace requires more free space +than is currently available. +.IP "NVME_SC_NS_ID_UNAVAILABLE" 12 +Namespace Identifier Unavailable: The +number of namespaces supported has been +exceeded. +.IP "NVME_SC_NS_ALREADY_ATTACHED" 12 +Namespace Already Attached: The +controller is already attached to the +namespace specified. +.IP "NVME_SC_NS_IS_PRIVATE" 12 +Namespace Is Private: The namespace is +private and is already attached to one +controller. +.IP "NVME_SC_NS_NOT_ATTACHED" 12 +Namespace Not Attached: The request to +detach the controller could not be +completed because the controller is not +attached to the namespace. +.IP "NVME_SC_THIN_PROV_NOT_SUPP" 12 +Thin Provisioning Not Supported: Thin +provisioning is not supported by the +controller. +.IP "NVME_SC_CTRL_LIST_INVALID" 12 +Controller List Invalid: The controller +list provided contains invalid controller +ids. +.IP "NVME_SC_SELF_TEST_IN_PROGRESS" 12 +Device Self-test In Progress: The controller +or NVM subsystem already has a device +self-test operation in process. +.IP "NVME_SC_BP_WRITE_PROHIBITED" 12 +Boot Partition Write Prohibited: The +command is trying to modify a locked Boot +Partition. +.IP "NVME_SC_INVALID_CTRL_ID" 12 +Invalid Controller Identifier: +.IP "NVME_SC_INVALID_SEC_CTRL_STATE" 12 +Invalid Secondary Controller State +.IP "NVME_SC_INVALID_CTRL_RESOURCES" 12 +Invalid Number of Controller Resources +.IP "NVME_SC_INVALID_RESOURCE_ID" 12 +Invalid Resource Identifier +.IP "NVME_SC_PMR_SAN_PROHIBITED" 12 +Sanitize Prohibited While Persistent +Memory Region is Enabled +.IP "NVME_SC_ANA_GROUP_ID_INVALID" 12 +ANA Group Identifier Invalid: The specified +ANA Group Identifier (ANAGRPID) is not +supported in the submitted command. +.IP "NVME_SC_ANA_ATTACH_FAILED" 12 +ANA Attach Failed: The controller is not +attached to the namespace as a result +of an ANA condition. +.IP "NVME_SC_INSUFFICIENT_CAP" 12 +Insufficient Capacity: Requested operation +requires more free space than is currently +available. +.IP "NVME_SC_NS_ATTACHMENT_LIMIT_EXCEEDED" 12 +Namespace Attachment Limit Exceeded: +Attaching the ns to a controller causes +max number of ns attachments allowed +to be exceeded. +.IP "NVME_SC_PROHIBIT_CMD_EXEC_NOT_SUPPORTED" 12 +Prohibition of Command Execution +Not Supported +.IP "NVME_SC_IOCS_NOT_SUPPORTED" 12 +I/O Command Set Not Supported +.IP "NVME_SC_IOCS_NOT_ENABLED" 12 +I/O Command Set Not Enabled +.IP "NVME_SC_IOCS_COMBINATION_REJECTED" 12 +I/O Command Set Combination Rejected +.IP "NVME_SC_INVALID_IOCS" 12 +Invalid I/O Command Set +.IP "NVME_SC_ID_UNAVAILABLE" 12 +Identifier Unavailable +.IP "NVME_SC_INVALID_DISCOVERY_INFO" 12 +The discovery information provided in +one or more extended discovery +information entries is not applicable +for the type of entity selected in +the Entity Type (ETYPE) field of the +Discovery Information Management +command data portion’s header. +.IP "NVME_SC_ZONING_DATA_STRUCT_LOCKED" 12 +The requested Zoning data structure +is locked on the CDC. +.IP "NVME_SC_ZONING_DATA_STRUCT_NOTFND" 12 +The requested Zoning data structure +does not exist on the CDC. +.IP "NVME_SC_INSUFFICIENT_DISC_RES" 12 +The number of discover information +entries provided in the data portion +of the Discovery Information +Management command for a registration +task (i.e., TAS field cleared to 0h) +exceeds the available capacity for +new discovery information entries on +the CDC or DDC. This may be a +transient condition. +.IP "NVME_SC_REQSTD_FUNCTION_DISABLED" 12 +Fabric Zoning is not enabled on the +CDC +.IP "NVME_SC_ZONEGRP_ORIGINATOR_INVLD" 12 +-- undescribed -- +.IP "NVME_SC_BAD_ATTRIBUTES" 12 +Conflicting Dataset Management Attributes +.IP "NVME_SC_INVALID_PI" 12 +Invalid Protection Information +.IP "NVME_SC_READ_ONLY" 12 +Attempted Write to Read Only Range +.IP "NVME_SC_CMD_SIZE_LIMIT_EXCEEDED" 12 +Command Size Limit Exceeded +.IP "NVME_SC_CONNECT_FORMAT" 12 +Incompatible Format: The NVM subsystem +does not support the record format +specified by the host. +.IP "NVME_SC_CONNECT_CTRL_BUSY" 12 +Controller Busy: The controller is +already associated with a host. +.IP "NVME_SC_CONNECT_INVALID_PARAM" 12 +Connect Invalid Parameters: One or more +of the command parameters. +.IP "NVME_SC_CONNECT_RESTART_DISC" 12 +Connect Restart Discovery: The NVM +subsystem requested is not available. +.IP "NVME_SC_CONNECT_INVALID_HOST" 12 +Connect Invalid Host: The host is either +not allowed to establish an association +to any controller in the NVM subsystem or +the host is not allowed to establish an +association to the specified controller +.IP "NVME_SC_DISCONNECT_INVALID_QTYPE" 12 +Invalid Queue Type: The command was sent +on the wrong queue type. +.IP "NVME_SC_DISCOVERY_RESTART" 12 +Discover Restart: The snapshot of the +records is now invalid or out of date. +.IP "NVME_SC_AUTH_REQUIRED" 12 +Authentication Required: NVMe in-band +authentication is required and the queue +has not yet been authenticated. +.IP "NVME_SC_ZNS_INVALID_OP_REQUEST" 12 +Invalid Zone Operation Request: +The operation requested is invalid. This may be due to +various conditions, including: attempting to allocate a +ZRWA when a zone is not in the ZSE:Empty state; or +invalid Flush Explicit ZRWA Range Send Zone Action +operation. +.IP "NVME_SC_ZNS_ZRWA_RESOURCES_UNAVAILABLE" 12 +ZRWA Resources Unavailable: +No ZRWAs are available. +.IP "NVME_SC_ZNS_BOUNDARY_ERROR" 12 +Zone Boundary Error: The command specifies +logical blocks in more than one zone. +.IP "NVME_SC_ZNS_FULL" 12 +Zone Is Full: The accessed zone is in the +ZSF:Full state. +.IP "NVME_SC_ZNS_READ_ONLY" 12 +Zone Is Read Only: The accessed zone is +in the ZSRO:Read Only state. +.IP "NVME_SC_ZNS_OFFLINE" 12 +Zone Is Offline: The accessed zone is +in the ZSO:Offline state. +.IP "NVME_SC_ZNS_INVALID_WRITE" 12 +Zone Invalid Write: The write to a zone +was not at the write pointer. +.IP "NVME_SC_ZNS_TOO_MANY_ACTIVE" 12 +Too Many Active Zones: The controller +does not allow additional active zones. +.IP "NVME_SC_ZNS_TOO_MANY_OPENS" 12 +Too Many Open Zones: The controller does +not allow additional open zones. +.IP "NVME_SC_ZNS_INVAL_TRANSITION" 12 +Invalid Zone State Transition: The request +is not a valid zone state transition. +.IP "NVME_SC_WRITE_FAULT" 12 +Write Fault: The write data could not be +committed to the media. +.IP "NVME_SC_READ_ERROR" 12 +Unrecovered Read Error: The read data +could not be recovered from the media. +.IP "NVME_SC_GUARD_CHECK" 12 +End-to-end Guard Check Error: The command +was aborted due to an end-to-end guard +check failure. +.IP "NVME_SC_APPTAG_CHECK" 12 +End-to-end Application Tag Check Error: +The command was aborted due to an +end-to-end application tag check failure. +.IP "NVME_SC_REFTAG_CHECK" 12 +End-to-end Reference Tag Check Error: The +command was aborted due to an end-to-end +reference tag check failure. +.IP "NVME_SC_COMPARE_FAILED" 12 +Compare Failure: The command failed due +to a miscompare during a Compare command. +.IP "NVME_SC_ACCESS_DENIED" 12 +Access Denied: Access to the namespace +and/or LBA range is denied due to lack of +access rights. +.IP "NVME_SC_UNWRITTEN_BLOCK" 12 +Deallocated or Unwritten Logical Block: +The command failed due to an attempt to +read from or verify an LBA range +containing a deallocated or unwritten +logical block. +.IP "NVME_SC_STORAGE_TAG_CHECK" 12 +End-to-End Storage Tag Check Error: The +command was aborted due to an end-to-end +storage tag check failure. +.IP "NVME_SC_ANA_INTERNAL_PATH_ERROR" 12 +Internal Path Error: The command was not +completed as the result of a controller +internal error that is specific to the +controller processing the command. +.IP "NVME_SC_ANA_PERSISTENT_LOSS" 12 +Asymmetric Access Persistent Loss: The +requested function (e.g., command) is not +able to be performed as a result of the +relationship between the controller and +the namespace being in the ANA Persistent +Loss state. +.IP "NVME_SC_ANA_INACCESSIBLE" 12 +Asymmetric Access Inaccessible: The +requested function (e.g., command) is not +able to be performed as a result of the +relationship between the controller and +the namespace being in the ANA +Inaccessible state. +.IP "NVME_SC_ANA_TRANSITION" 12 +Asymmetric Access Transition: The +requested function (e.g., command) is not +able to be performed as a result of the +relationship between the controller and +the namespace transitioning between +Asymmetric Namespace Access states. +.IP "NVME_SC_CTRL_PATH_ERROR" 12 +Controller Pathing Error: A pathing error +was detected by the controller. +.IP "NVME_SC_HOST_PATH_ERROR" 12 +Host Pathing Error: A pathing error was +detected by the host. +.IP "NVME_SC_CMD_ABORTED_BY_HOST" 12 +Command Aborted By Host: The command was +aborted as a result of host action. +.IP "NVME_SC_CRD" 12 +Mask to get value of Command Retry Delay +index +.IP "NVME_SC_MORE" 12 +More bit. If set, more status information +for this command as part of the Error +Information log that may be retrieved with +the Get Log Page command. +.IP "NVME_SC_DNR" 12 +Do Not Retry bit. If set, if the same +command is re-submitted to any controller +in the NVM subsystem, then that +re-submitted command is expected to fail. diff --git a/doc/man/nvme_status_result.2 b/doc/man/nvme_status_result.2 new file mode 100644 index 0000000..e1e51ad --- /dev/null +++ b/doc/man/nvme_status_result.2 @@ -0,0 +1,87 @@ +.TH "libnvme" 9 "enum nvme_status_result" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_status_result \- Result of the device self-test operation +.SH SYNOPSIS +enum nvme_status_result { +.br +.BI " NVME_ST_RESULT_NO_ERR" +, +.br +.br +.BI " NVME_ST_RESULT_ABORTED" +, +.br +.br +.BI " NVME_ST_RESULT_CLR" +, +.br +.br +.BI " NVME_ST_RESULT_NS_REMOVED" +, +.br +.br +.BI " NVME_ST_RESULT_ABORTED_FORMAT" +, +.br +.br +.BI " NVME_ST_RESULT_FATAL_ERR" +, +.br +.br +.BI " NVME_ST_RESULT_UNKNOWN_SEG_FAIL" +, +.br +.br +.BI " NVME_ST_RESULT_KNOWN_SEG_FAIL" +, +.br +.br +.BI " NVME_ST_RESULT_ABORTED_UNKNOWN" +, +.br +.br +.BI " NVME_ST_RESULT_ABORTED_SANITIZE" +, +.br +.br +.BI " NVME_ST_RESULT_NOT_USED" +, +.br +.br +.BI " NVME_ST_RESULT_MASK" + +}; +.SH Constants +.IP "NVME_ST_RESULT_NO_ERR" 12 +Operation completed without error. +.IP "NVME_ST_RESULT_ABORTED" 12 +Operation was aborted by a Device Self-test command. +.IP "NVME_ST_RESULT_CLR" 12 +Operation was aborted by a Controller Level Reset. +.IP "NVME_ST_RESULT_NS_REMOVED" 12 +Operation was aborted due to a removal of +a namespace from the namespace inventory. +.IP "NVME_ST_RESULT_ABORTED_FORMAT" 12 +Operation was aborted due to the processing +of a Format NVM command. +.IP "NVME_ST_RESULT_FATAL_ERR" 12 +A fatal error or unknown test error occurred +while the controller was executing the device +self-test operation and the operation did +not complete. +.IP "NVME_ST_RESULT_UNKNOWN_SEG_FAIL" 12 +Operation completed with a segment that failed +and the segment that failed is not known. +.IP "NVME_ST_RESULT_KNOWN_SEG_FAIL" 12 +Operation completed with one or more failed +segments and the first segment that failed +is indicated in the Segment Number field. +.IP "NVME_ST_RESULT_ABORTED_UNKNOWN" 12 +Operation was aborted for unknown reason. +.IP "NVME_ST_RESULT_ABORTED_SANITIZE" 12 +Operation was aborted due to a sanitize operation. +.IP "NVME_ST_RESULT_NOT_USED" 12 +Entry not used (does not contain a test result). +.IP "NVME_ST_RESULT_MASK" 12 +Mask to get the status result value from +the \fIstruct nvme_st_result\fP.dsts field. diff --git a/doc/man/nvme_status_to_errno.2 b/doc/man/nvme_status_to_errno.2 new file mode 100644 index 0000000..d5174a7 --- /dev/null +++ b/doc/man/nvme_status_to_errno.2 @@ -0,0 +1,15 @@ +.TH "nvme_status_to_errno" 9 "nvme_status_to_errno" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_status_to_errno \- Converts nvme return status to errno +.SH SYNOPSIS +.B "__u8" nvme_status_to_errno +.BI "(int status " "," +.BI "bool fabrics " ");" +.SH ARGUMENTS +.IP "status" 12 +Return status from an nvme passthrough commmand +.IP "fabrics" 12 +Set to true if \fIstatus\fP is to a fabrics target. +.SH "RETURN" +An errno representing the nvme status if it is an nvme status field, +or unchanged status is < 0 since errno is already set. diff --git a/doc/man/nvme_status_to_string.2 b/doc/man/nvme_status_to_string.2 new file mode 100644 index 0000000..c91938d --- /dev/null +++ b/doc/man/nvme_status_to_string.2 @@ -0,0 +1,15 @@ +.TH "nvme_status_to_string" 9 "nvme_status_to_string" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_status_to_string \- Returns string describing nvme return status. +.SH SYNOPSIS +.B "const char *" nvme_status_to_string +.BI "(int status " "," +.BI "bool fabrics " ");" +.SH ARGUMENTS +.IP "status" 12 +Return status from an nvme passthrough commmand +.IP "fabrics" 12 +Set to true if \fIstatus\fP is to a fabrics target. +.SH "RETURN" +String representation of the nvme status if it is an nvme status field, +or a standard errno string if status is < 0. diff --git a/doc/man/nvme_streams_directive_params.2 b/doc/man/nvme_streams_directive_params.2 new file mode 100644 index 0000000..c2dd59a --- /dev/null +++ b/doc/man/nvme_streams_directive_params.2 @@ -0,0 +1,51 @@ +.TH "libnvme" 9 "struct nvme_streams_directive_params" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_streams_directive_params \- +.SH SYNOPSIS +struct nvme_streams_directive_params { +.br +.BI " __le16 msl;" +.br +.BI " __le16 nssa;" +.br +.BI " __le16 nsso;" +.br +.BI " __u8 nssc;" +.br +.BI " __u8 rsvd[9];" +.br +.BI " __le32 sws;" +.br +.BI " __le16 sgs;" +.br +.BI " __le16 nsa;" +.br +.BI " __le16 nso;" +.br +.BI " __u8 rsvd2[6];" +.br +.BI " +}; +.br + +.SH Members +.IP "msl" 12 +Max Streams Limit +.IP "nssa" 12 +NVM Subsystem Streams Available +.IP "nsso" 12 +NVM Subsystem Streams Open +.IP "nssc" 12 +NVM Subsystem Stream Capability +.IP "rsvd" 12 +Reserved +.IP "sws" 12 +Stream Write Size +.IP "sgs" 12 +Stream Granularity Size +.IP "nsa" 12 +Namespace Streams Allocated +.IP "nso" 12 +Namespace Streams Open +.IP "rsvd2" 12 +Reserved diff --git a/doc/man/nvme_streams_directive_status.2 b/doc/man/nvme_streams_directive_status.2 new file mode 100644 index 0000000..5b0a192 --- /dev/null +++ b/doc/man/nvme_streams_directive_status.2 @@ -0,0 +1,19 @@ +.TH "libnvme" 9 "struct nvme_streams_directive_status" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_streams_directive_status \- +.SH SYNOPSIS +struct nvme_streams_directive_status { +.br +.BI " __le16 osc;" +.br +.BI " __le16 sid[];" +.br +.BI " +}; +.br + +.SH Members +.IP "osc" 12 +Open Stream Count +.IP "sid" 12 +Stream Identifier diff --git a/doc/man/nvme_submit_admin_passthru.2 b/doc/man/nvme_submit_admin_passthru.2 new file mode 100644 index 0000000..823bbff --- /dev/null +++ b/doc/man/nvme_submit_admin_passthru.2 @@ -0,0 +1,20 @@ +.TH "nvme_submit_admin_passthru" 9 "nvme_submit_admin_passthru" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_submit_admin_passthru \- Submit an nvme passthrough admin command +.SH SYNOPSIS +.B "int" nvme_submit_admin_passthru +.BI "(int fd " "," +.BI "struct nvme_passthru_cmd *cmd " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "cmd" 12 +The nvme admin command to send +.IP "result" 12 +Optional field to return the result from the CQE DW0 +.SH "DESCRIPTION" +Uses NVME_IOCTL_ADMIN_CMD for the ioctl request. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_submit_io_passthru.2 b/doc/man/nvme_submit_io_passthru.2 new file mode 100644 index 0000000..8319a47 --- /dev/null +++ b/doc/man/nvme_submit_io_passthru.2 @@ -0,0 +1,20 @@ +.TH "nvme_submit_io_passthru" 9 "nvme_submit_io_passthru" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_submit_io_passthru \- Submit an nvme passthrough command +.SH SYNOPSIS +.B "int" nvme_submit_io_passthru +.BI "(int fd " "," +.BI "struct nvme_passthru_cmd *cmd " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "cmd" 12 +The nvme io command to send +.IP "result" 12 +Optional field to return the result from the CQE DW0 +.SH "DESCRIPTION" +Uses NVME_IOCTL_IO_CMD for the ioctl request. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_subsys_filter.2 b/doc/man/nvme_subsys_filter.2 new file mode 100644 index 0000000..c53a5e5 --- /dev/null +++ b/doc/man/nvme_subsys_filter.2 @@ -0,0 +1,11 @@ +.TH "nvme_subsys_filter" 9 "nvme_subsys_filter" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_subsys_filter \- Filter for subsystems +.SH SYNOPSIS +.B "int" nvme_subsys_filter +.BI "(const struct dirent *d " ");" +.SH ARGUMENTS +.IP "d" 12 +dirent to check +.SH "RETURN" +1 if \fId\fP matches, 0 otherwise diff --git a/doc/man/nvme_subsys_type.2 b/doc/man/nvme_subsys_type.2 new file mode 100644 index 0000000..8abd195 --- /dev/null +++ b/doc/man/nvme_subsys_type.2 @@ -0,0 +1,37 @@ +.TH "libnvme" 9 "enum nvme_subsys_type" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_subsys_type \- Type of the NVM subsystem. +.SH SYNOPSIS +enum nvme_subsys_type { +.br +.BI " NVME_NQN_DISC" +, +.br +.br +.BI " NVME_NQN_NVME" +, +.br +.br +.BI " NVME_NQN_CURR" + +}; +.SH Constants +.IP "NVME_NQN_DISC" 12 +Discovery type target subsystem. Describes a referral to another +Discovery Service composed of Discovery controllers that provide +additional discovery records. Multiple Referral entries may +be reported for each Discovery Service (if that Discovery Service +has multiple NVM subsystem ports or supports multiple protocols). +.IP "NVME_NQN_NVME" 12 +NVME type target subsystem. Describes an NVM subsystem whose +controllers may have attached namespaces (an NVM subsystem +that is not composed of Discovery controllers). Multiple NVM +Subsystem entries may be reported for each NVM subsystem if +that NVM subsystem has multiple NVM subsystem ports. +.IP "NVME_NQN_CURR" 12 +Current Discovery type target subsystem. Describes this Discovery +subsystem (the Discovery Service that contains the controller +processing the Get Log Page command). Multiple Current Discovery +Subsystem entries may be reported for this Discovery subsystem +if the current Discovery subsystem has multiple NVM subsystem +ports. diff --git a/doc/man/nvme_subsystem_first_ctrl.2 b/doc/man/nvme_subsystem_first_ctrl.2 new file mode 100644 index 0000000..0080c21 --- /dev/null +++ b/doc/man/nvme_subsystem_first_ctrl.2 @@ -0,0 +1,11 @@ +.TH "nvme_subsystem_first_ctrl" 9 "nvme_subsystem_first_ctrl" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_subsystem_first_ctrl \- First ctrl iterator +.SH SYNOPSIS +.B "nvme_ctrl_t" nvme_subsystem_first_ctrl +.BI "(nvme_subsystem_t s " ");" +.SH ARGUMENTS +.IP "s" 12 +\fInvme_subsystem_t\fP object +.SH "RETURN" +First controller of an \fIs\fP iterator diff --git a/doc/man/nvme_subsystem_first_ns.2 b/doc/man/nvme_subsystem_first_ns.2 new file mode 100644 index 0000000..77e6f06 --- /dev/null +++ b/doc/man/nvme_subsystem_first_ns.2 @@ -0,0 +1,11 @@ +.TH "nvme_subsystem_first_ns" 9 "nvme_subsystem_first_ns" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_subsystem_first_ns \- Start namespace iterator +.SH SYNOPSIS +.B "nvme_ns_t" nvme_subsystem_first_ns +.BI "(nvme_subsystem_t s " ");" +.SH ARGUMENTS +.IP "s" 12 +\fInvme_subsystem_t\fP object +.SH "RETURN" +First \fInvme_ns_t\fP object of an \fIs\fP iterator diff --git a/doc/man/nvme_subsystem_for_each_ctrl.2 b/doc/man/nvme_subsystem_for_each_ctrl.2 new file mode 100644 index 0000000..b2f90f1 --- /dev/null +++ b/doc/man/nvme_subsystem_for_each_ctrl.2 @@ -0,0 +1,12 @@ +.TH "nvme_subsystem_for_each_ctrl" 9 "nvme_subsystem_for_each_ctrl" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_subsystem_for_each_ctrl \- Traverse controllers +.SH SYNOPSIS +.B "nvme_subsystem_for_each_ctrl +.BI "(s " "," +.BI "c " ");" +.SH ARGUMENTS +.IP "s" 12 +\fInvme_subsystem_t\fP object +.IP "c" 12 +Controller instance diff --git a/doc/man/nvme_subsystem_for_each_ctrl_safe.2 b/doc/man/nvme_subsystem_for_each_ctrl_safe.2 new file mode 100644 index 0000000..5c61ad8 --- /dev/null +++ b/doc/man/nvme_subsystem_for_each_ctrl_safe.2 @@ -0,0 +1,15 @@ +.TH "nvme_subsystem_for_each_ctrl_safe" 9 "nvme_subsystem_for_each_ctrl_safe" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_subsystem_for_each_ctrl_safe \- Traverse controllers +.SH SYNOPSIS +.B "nvme_subsystem_for_each_ctrl_safe +.BI "(s " "," +.BI "c " "," +.BI "_c " ");" +.SH ARGUMENTS +.IP "s" 12 +\fInvme_subsystem_t\fP object +.IP "c" 12 +Controller instance +.IP "_c" 12 +A \fInvme_ctrl_t_node\fP to use as temporary storage diff --git a/doc/man/nvme_subsystem_for_each_ns.2 b/doc/man/nvme_subsystem_for_each_ns.2 new file mode 100644 index 0000000..ed20603 --- /dev/null +++ b/doc/man/nvme_subsystem_for_each_ns.2 @@ -0,0 +1,12 @@ +.TH "nvme_subsystem_for_each_ns" 9 "nvme_subsystem_for_each_ns" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_subsystem_for_each_ns \- Traverse namespaces +.SH SYNOPSIS +.B "nvme_subsystem_for_each_ns +.BI "(s " "," +.BI "n " ");" +.SH ARGUMENTS +.IP "s" 12 +\fInvme_subsystem_t\fP object +.IP "n" 12 +\fInvme_ns_t\fP object diff --git a/doc/man/nvme_subsystem_for_each_ns_safe.2 b/doc/man/nvme_subsystem_for_each_ns_safe.2 new file mode 100644 index 0000000..7b565bf --- /dev/null +++ b/doc/man/nvme_subsystem_for_each_ns_safe.2 @@ -0,0 +1,15 @@ +.TH "nvme_subsystem_for_each_ns_safe" 9 "nvme_subsystem_for_each_ns_safe" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_subsystem_for_each_ns_safe \- Traverse namespaces +.SH SYNOPSIS +.B "nvme_subsystem_for_each_ns_safe +.BI "(s " "," +.BI "n " "," +.BI "_n " ");" +.SH ARGUMENTS +.IP "s" 12 +\fInvme_subsystem_t\fP object +.IP "n" 12 +\fInvme_ns_t\fP object +.IP "_n" 12 +A \fInvme_ns_t_node\fP to use as temporary storage diff --git a/doc/man/nvme_subsystem_get_host.2 b/doc/man/nvme_subsystem_get_host.2 new file mode 100644 index 0000000..cdabc3f --- /dev/null +++ b/doc/man/nvme_subsystem_get_host.2 @@ -0,0 +1,11 @@ +.TH "nvme_subsystem_get_host" 9 "nvme_subsystem_get_host" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_subsystem_get_host \- Returns nvme_host_t object +.SH SYNOPSIS +.B "nvme_host_t" nvme_subsystem_get_host +.BI "(nvme_subsystem_t s " ");" +.SH ARGUMENTS +.IP "s" 12 +subsystem +.SH "RETURN" +\fInvme_host_t\fP object from \fIs\fP diff --git a/doc/man/nvme_subsystem_get_name.2 b/doc/man/nvme_subsystem_get_name.2 new file mode 100644 index 0000000..a5c7335 --- /dev/null +++ b/doc/man/nvme_subsystem_get_name.2 @@ -0,0 +1,11 @@ +.TH "nvme_subsystem_get_name" 9 "nvme_subsystem_get_name" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_subsystem_get_name \- sysfs name of an nvme_subsystem_t object +.SH SYNOPSIS +.B "const char *" nvme_subsystem_get_name +.BI "(nvme_subsystem_t s " ");" +.SH ARGUMENTS +.IP "s" 12 +nvme_subsystem_t object +.SH "RETURN" +sysfs name of \fIs\fP diff --git a/doc/man/nvme_subsystem_get_nqn.2 b/doc/man/nvme_subsystem_get_nqn.2 new file mode 100644 index 0000000..45aea5e --- /dev/null +++ b/doc/man/nvme_subsystem_get_nqn.2 @@ -0,0 +1,11 @@ +.TH "nvme_subsystem_get_nqn" 9 "nvme_subsystem_get_nqn" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_subsystem_get_nqn \- Retrieve NQN from subsystem +.SH SYNOPSIS +.B "const char *" nvme_subsystem_get_nqn +.BI "(nvme_subsystem_t s " ");" +.SH ARGUMENTS +.IP "s" 12 +nvme_subsystem_t object +.SH "RETURN" +NQN of systemstem diff --git a/doc/man/nvme_subsystem_get_sysfs_dir.2 b/doc/man/nvme_subsystem_get_sysfs_dir.2 new file mode 100644 index 0000000..d07e445 --- /dev/null +++ b/doc/man/nvme_subsystem_get_sysfs_dir.2 @@ -0,0 +1,11 @@ +.TH "nvme_subsystem_get_sysfs_dir" 9 "nvme_subsystem_get_sysfs_dir" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_subsystem_get_sysfs_dir \- sysfs directory of an nvme_subsystem_t object +.SH SYNOPSIS +.B "const char *" nvme_subsystem_get_sysfs_dir +.BI "(nvme_subsystem_t s " ");" +.SH ARGUMENTS +.IP "s" 12 +nvme_subsystem_t object +.SH "RETURN" +sysfs directory name of \fIs\fP diff --git a/doc/man/nvme_subsystem_get_type.2 b/doc/man/nvme_subsystem_get_type.2 new file mode 100644 index 0000000..55c1b99 --- /dev/null +++ b/doc/man/nvme_subsystem_get_type.2 @@ -0,0 +1,13 @@ +.TH "nvme_subsystem_get_type" 9 "nvme_subsystem_get_type" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_subsystem_get_type \- Returns the type of a subsystem +.SH SYNOPSIS +.B "const char *" nvme_subsystem_get_type +.BI "(nvme_subsystem_t s " ");" +.SH ARGUMENTS +.IP "s" 12 +nvme_subsystem_t object +.SH "DESCRIPTION" +Returns the subsystem type of \fIs\fP. +.SH "RETURN" +'nvm' or 'discovery' diff --git a/doc/man/nvme_subsystem_lookup_namespace.2 b/doc/man/nvme_subsystem_lookup_namespace.2 new file mode 100644 index 0000000..201c3fd --- /dev/null +++ b/doc/man/nvme_subsystem_lookup_namespace.2 @@ -0,0 +1,14 @@ +.TH "nvme_subsystem_lookup_namespace" 9 "nvme_subsystem_lookup_namespace" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_subsystem_lookup_namespace \- lookup namespace by NSID +.SH SYNOPSIS +.B "nvme_ns_t" nvme_subsystem_lookup_namespace +.BI "(struct nvme_subsystem *s " "," +.BI "__u32 nsid " ");" +.SH ARGUMENTS +.IP "s" 12 +nvme_subsystem_t object +.IP "nsid" 12 +Namespace id +.SH "RETURN" +nvme_ns_t of the namespace with id \fInsid\fP in subsystem \fIs\fP diff --git a/doc/man/nvme_subsystem_next_ctrl.2 b/doc/man/nvme_subsystem_next_ctrl.2 new file mode 100644 index 0000000..971ab8a --- /dev/null +++ b/doc/man/nvme_subsystem_next_ctrl.2 @@ -0,0 +1,14 @@ +.TH "nvme_subsystem_next_ctrl" 9 "nvme_subsystem_next_ctrl" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_subsystem_next_ctrl \- Next ctrl iterator +.SH SYNOPSIS +.B "nvme_ctrl_t" nvme_subsystem_next_ctrl +.BI "(nvme_subsystem_t s " "," +.BI "nvme_ctrl_t c " ");" +.SH ARGUMENTS +.IP "s" 12 +\fInvme_subsystem_t\fP object +.IP "c" 12 +Previous controller instance of an \fIs\fP iterator +.SH "RETURN" +Next controller of an \fIs\fP iterator diff --git a/doc/man/nvme_subsystem_next_ns.2 b/doc/man/nvme_subsystem_next_ns.2 new file mode 100644 index 0000000..fad424e --- /dev/null +++ b/doc/man/nvme_subsystem_next_ns.2 @@ -0,0 +1,14 @@ +.TH "nvme_subsystem_next_ns" 9 "nvme_subsystem_next_ns" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_subsystem_next_ns \- Next namespace iterator +.SH SYNOPSIS +.B "nvme_ns_t" nvme_subsystem_next_ns +.BI "(nvme_subsystem_t s " "," +.BI "nvme_ns_t n " ");" +.SH ARGUMENTS +.IP "s" 12 +\fInvme_subsystem_t\fP object +.IP "n" 12 +Previous \fInvme_ns_t\fP iterator +.SH "RETURN" +Next \fInvme_ns_t\fP object of an \fIs\fP iterator diff --git a/doc/man/nvme_subsystem_reset.2 b/doc/man/nvme_subsystem_reset.2 new file mode 100644 index 0000000..6f96dcf --- /dev/null +++ b/doc/man/nvme_subsystem_reset.2 @@ -0,0 +1,14 @@ +.TH "nvme_subsystem_reset" 9 "nvme_subsystem_reset" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_subsystem_reset \- Initiate a subsystem reset +.SH SYNOPSIS +.B "int" nvme_subsystem_reset +.BI "(int fd " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.SH "DESCRIPTION" +This should only be sent to controller handles, not to namespaces. +.SH "RETURN" +Zero if a subsystem reset was initiated or -1 with errno set +otherwise. diff --git a/doc/man/nvme_supported_cap_config_list_log.2 b/doc/man/nvme_supported_cap_config_list_log.2 new file mode 100644 index 0000000..b842e36 --- /dev/null +++ b/doc/man/nvme_supported_cap_config_list_log.2 @@ -0,0 +1,22 @@ +.TH "libnvme" 9 "struct nvme_supported_cap_config_list_log" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_supported_cap_config_list_log \- +.SH SYNOPSIS +struct nvme_supported_cap_config_list_log { +.br +.BI " __u8 sccn;" +.br +.BI " __u8 rsvd1[15];" +.br +.BI " struct nvme_capacity_config_desc cap_config_desc[];" +.br +.BI " +}; +.br + +.SH Members +.IP "sccn" 12 +number of capacity configuration +.SH "Description" +Supported Capacity Configuration list log page +structure definitions diff --git a/doc/man/nvme_supported_log_pages.2 b/doc/man/nvme_supported_log_pages.2 new file mode 100644 index 0000000..4ff8d55 --- /dev/null +++ b/doc/man/nvme_supported_log_pages.2 @@ -0,0 +1,17 @@ +.TH "libnvme" 9 "struct nvme_supported_log_pages" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_supported_log_pages \- +.SH SYNOPSIS +struct nvme_supported_log_pages { +.br +.BI " __le32 lid_support[NVME_LOG_SUPPORTED_LOG_PAGES_MAX];" +.br +.BI " +}; +.br + +.SH Members +.IP "lid_support" 12 +Log Page Identifier Supported +.SH "Description" +Supported Log Pages (Log Identifier 00h) diff --git a/doc/man/nvme_telemetry_da.2 b/doc/man/nvme_telemetry_da.2 new file mode 100644 index 0000000..7ba72d7 --- /dev/null +++ b/doc/man/nvme_telemetry_da.2 @@ -0,0 +1,30 @@ +.TH "libnvme" 9 "enum nvme_telemetry_da" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_telemetry_da \- Telemetry Log Data Area +.SH SYNOPSIS +enum nvme_telemetry_da { +.br +.BI " NVME_TELEMETRY_DA_1" +, +.br +.br +.BI " NVME_TELEMETRY_DA_2" +, +.br +.br +.BI " NVME_TELEMETRY_DA_3" +, +.br +.br +.BI " NVME_TELEMETRY_DA_4" + +}; +.SH Constants +.IP "NVME_TELEMETRY_DA_1" 12 +Data Area 1 +.IP "NVME_TELEMETRY_DA_2" 12 +Data Area 2 +.IP "NVME_TELEMETRY_DA_3" 12 +Data Area 3 +.IP "NVME_TELEMETRY_DA_4" 12 +Data Area 4 diff --git a/doc/man/nvme_telemetry_log.2 b/doc/man/nvme_telemetry_log.2 new file mode 100644 index 0000000..4ee5d67 --- /dev/null +++ b/doc/man/nvme_telemetry_log.2 @@ -0,0 +1,88 @@ +.TH "libnvme" 9 "struct nvme_telemetry_log" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_telemetry_log \- Retrieve internal data specific to the manufacturer. +.SH SYNOPSIS +struct nvme_telemetry_log { +.br +.BI " __u8 lpi;" +.br +.BI " __u8 rsvd1[4];" +.br +.BI " __u8 ieee[3];" +.br +.BI " __le16 dalb1;" +.br +.BI " __le16 dalb2;" +.br +.BI " __le16 dalb3;" +.br +.BI " __u8 rsvd14[2];" +.br +.BI " __le32 dalb4;" +.br +.BI " __u8 rsvd20[361];" +.br +.BI " __u8 hostdgn;" +.br +.BI " __u8 ctrlavail;" +.br +.BI " __u8 ctrldgn;" +.br +.BI " __u8 rsnident[128];" +.br +.BI " __u8 data_area[];" +.br +.BI " +}; +.br + +.SH Members +.IP "lpi" 12 +Log Identifier, either NVME_LOG_LID_TELEMETRY_HOST or +NVME_LOG_LID_TELEMETRY_CTRL +.IP "rsvd1" 12 +Reserved +.IP "ieee" 12 +IEEE OUI Identifier is the Organization Unique Identifier (OUI) +for the controller vendor that is able to interpret the data. +.IP "dalb1" 12 +Telemetry Controller-Initiated Data Area 1 Last Block is +the value of the last block in this area. +.IP "dalb2" 12 +Telemetry Controller-Initiated Data Area 1 Last Block is +the value of the last block in this area. +.IP "dalb3" 12 +Telemetry Controller-Initiated Data Area 1 Last Block is +the value of the last block in this area. +.IP "rsvd14" 12 +Reserved +.IP "dalb4" 12 +Telemetry Controller-Initiated Data Area 4 Last Block is +the value of the last block in this area. +.IP "rsvd20" 12 +Reserved +.IP "hostdgn" 12 +Telemetry Host-Initiated Data Generation Number is a +value that is incremented each time the host initiates a +capture of its internal controller state in the controller . +.IP "ctrlavail" 12 +Telemetry Controller-Initiated Data Available, if cleared, +then the controller telemetry log does not contain saved +internal controller state. If this field is set to 1h, the +controller log contains saved internal controller state. If +this field is set to 1h, the data will be latched until the +host releases it by reading the log with RAE cleared. +.IP "ctrldgn" 12 +Telemetry Controller-Initiated Data Generation Number is +a value that is incremented each time the controller initiates a +capture of its internal controller state in the controller . +.IP "rsnident" 12 +Reason Identifieris a vendor specific identifier that describes +the operating conditions of the controller at the time of +capture. +.IP "data_area" 12 +Telemetry data blocks, vendor specific information data. +.SH "Description" +This log consists of a header describing the log and zero or more Telemetry +Data Blocks. All Telemetry Data Blocks are NVME_LOG_TELEM_BLOCK_SIZE, 512 +bytes, in size. This log captures the controller’s internal state. diff --git a/doc/man/nvme_thermal_exc_event.2 b/doc/man/nvme_thermal_exc_event.2 new file mode 100644 index 0000000..a50ff57 --- /dev/null +++ b/doc/man/nvme_thermal_exc_event.2 @@ -0,0 +1,19 @@ +.TH "libnvme" 9 "struct nvme_thermal_exc_event" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_thermal_exc_event \- +.SH SYNOPSIS +struct nvme_thermal_exc_event { +.br +.BI " __u8 over_temp;" +.br +.BI " __u8 threshold;" +.br +.BI " +}; +.br + +.SH Members +.IP "over_temp" 12 +Over Temperature +.IP "threshold" 12 +temperature threshold diff --git a/doc/man/nvme_time_stamp_change_event.2 b/doc/man/nvme_time_stamp_change_event.2 new file mode 100644 index 0000000..3a01771 --- /dev/null +++ b/doc/man/nvme_time_stamp_change_event.2 @@ -0,0 +1,19 @@ +.TH "libnvme" 9 "struct nvme_time_stamp_change_event" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_time_stamp_change_event \- +.SH SYNOPSIS +struct nvme_time_stamp_change_event { +.br +.BI " __le64 previous_timestamp;" +.br +.BI " __le64 ml_secs_since_reset;" +.br +.BI " +}; +.br + +.SH Members +.IP "previous_timestamp" 12 +Previous Timestamp +.IP "ml_secs_since_reset" 12 +Milliseconds Since Reset diff --git a/doc/man/nvme_timestamp.2 b/doc/man/nvme_timestamp.2 new file mode 100644 index 0000000..97d6ee3 --- /dev/null +++ b/doc/man/nvme_timestamp.2 @@ -0,0 +1,23 @@ +.TH "libnvme" 9 "struct nvme_timestamp" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_timestamp \- +.SH SYNOPSIS +struct nvme_timestamp { +.br +.BI " __u8 timestamp[6];" +.br +.BI " __u8 attr;" +.br +.BI " __u8 rsvd;" +.br +.BI " +}; +.br + +.SH Members +.IP "timestamp" 12 +Timestamp value based on origin and synch field +.IP "attr" 12 +Attribute +.IP "rsvd" 12 +Reserved diff --git a/doc/man/nvme_unlink_ctrl.2 b/doc/man/nvme_unlink_ctrl.2 new file mode 100644 index 0000000..8ef69e8 --- /dev/null +++ b/doc/man/nvme_unlink_ctrl.2 @@ -0,0 +1,9 @@ +.TH "nvme_unlink_ctrl" 9 "nvme_unlink_ctrl" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_unlink_ctrl \- Unlink controller +.SH SYNOPSIS +.B "void" nvme_unlink_ctrl +.BI "(struct nvme_ctrl *c " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance diff --git a/doc/man/nvme_update_config.2 b/doc/man/nvme_update_config.2 new file mode 100644 index 0000000..c3357e2 --- /dev/null +++ b/doc/man/nvme_update_config.2 @@ -0,0 +1,13 @@ +.TH "nvme_update_config" 9 "nvme_update_config" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_update_config \- Update JSON configuration +.SH SYNOPSIS +.B "int" nvme_update_config +.BI "(nvme_root_t r " ");" +.SH ARGUMENTS +.IP "r" 12 +nvme_root_t object +.SH "DESCRIPTION" +Updates the JSON configuration file with the contents of \fIr\fP. +.SH "RETURN" +0 on success, -1 on failure. diff --git a/doc/man/nvme_verify.2 b/doc/man/nvme_verify.2 new file mode 100644 index 0000000..000ae7f --- /dev/null +++ b/doc/man/nvme_verify.2 @@ -0,0 +1,16 @@ +.TH "nvme_verify" 9 "nvme_verify" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_verify \- Send an nvme verify command +.SH SYNOPSIS +.B "int" nvme_verify +.BI "(struct nvme_io_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_io_args\fP argument structure +.SH "DESCRIPTION" +The Verify command verifies integrity of stored information by reading data +and metadata, if applicable, for the LBAs indicated without transferring any +data or metadata to the host. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_virt_mgmt_act.2 b/doc/man/nvme_virt_mgmt_act.2 new file mode 100644 index 0000000..a04cf35 --- /dev/null +++ b/doc/man/nvme_virt_mgmt_act.2 @@ -0,0 +1,31 @@ +.TH "libnvme" 9 "enum nvme_virt_mgmt_act" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_virt_mgmt_act \- +.SH SYNOPSIS +enum nvme_virt_mgmt_act { +.br +.BI " NVME_VIRT_MGMT_ACT_PRIM_CTRL_FLEX_ALLOC" +, +.br +.br +.BI " NVME_VIRT_MGMT_ACT_OFFLINE_SEC_CTRL" +, +.br +.br +.BI " NVME_VIRT_MGMT_ACT_ASSIGN_SEC_CTRL" +, +.br +.br +.BI " NVME_VIRT_MGMT_ACT_ONLINE_SEC_CTRL" + +}; +.SH Constants +.IP "NVME_VIRT_MGMT_ACT_PRIM_CTRL_FLEX_ALLOC" 12 +Primary Controller Flexible +Allocation +.IP "NVME_VIRT_MGMT_ACT_OFFLINE_SEC_CTRL" 12 +Secondary Controller Offline +.IP "NVME_VIRT_MGMT_ACT_ASSIGN_SEC_CTRL" 12 +Secondary Controller Assign +.IP "NVME_VIRT_MGMT_ACT_ONLINE_SEC_CTRL" 12 +Secondary Controller Online diff --git a/doc/man/nvme_virt_mgmt_rt.2 b/doc/man/nvme_virt_mgmt_rt.2 new file mode 100644 index 0000000..99db5e0 --- /dev/null +++ b/doc/man/nvme_virt_mgmt_rt.2 @@ -0,0 +1,18 @@ +.TH "libnvme" 9 "enum nvme_virt_mgmt_rt" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_virt_mgmt_rt \- +.SH SYNOPSIS +enum nvme_virt_mgmt_rt { +.br +.BI " NVME_VIRT_MGMT_RT_VQ_RESOURCE" +, +.br +.br +.BI " NVME_VIRT_MGMT_RT_VI_RESOURCE" + +}; +.SH Constants +.IP "NVME_VIRT_MGMT_RT_VQ_RESOURCE" 12 +VQ Resources +.IP "NVME_VIRT_MGMT_RT_VI_RESOURCE" 12 +VI Resources diff --git a/doc/man/nvme_virtual_mgmt.2 b/doc/man/nvme_virtual_mgmt.2 new file mode 100644 index 0000000..ece162d --- /dev/null +++ b/doc/man/nvme_virtual_mgmt.2 @@ -0,0 +1,20 @@ +.TH "nvme_virtual_mgmt" 9 "nvme_virtual_mgmt" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_virtual_mgmt \- Virtualization resource management +.SH SYNOPSIS +.B "int" nvme_virtual_mgmt +.BI "(struct nvme_virtual_mgmt_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_virtual_mgmt_args\fP argument structure +.SH "DESCRIPTION" +The Virtualization Management command is supported by primary controllers +that support the Virtualization Enhancements capability. This command is +used for several functions: + +- Modifying Flexible Resource allocation for the primary controller +- Assigning Flexible Resources for secondary controllers +- Setting the Online and Offline state for secondary controllers +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_virtual_mgmt_args.2 b/doc/man/nvme_virtual_mgmt_args.2 new file mode 100644 index 0000000..d072b4c --- /dev/null +++ b/doc/man/nvme_virtual_mgmt_args.2 @@ -0,0 +1,43 @@ +.TH "libnvme" 9 "struct nvme_virtual_mgmt_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_virtual_mgmt_args \- Arguments for the NVMe Virtualization resource management command +.SH SYNOPSIS +struct nvme_virtual_mgmt_args { +.br +.BI " __u32 *result;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " enum nvme_virt_mgmt_act act;" +.br +.BI " enum nvme_virt_mgmt_rt rt;" +.br +.BI " __u16 cntlid;" +.br +.BI " __u16 nr;" +.br +.BI " +}; +.br + +.SH Members +.IP "result" 12 +If successful, the CQE dword0 +.IP "args_size" 12 +Size of \fIstruct nvme_virtual_mgmt_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "act" 12 +Virtual resource action, see \fIenum nvme_virt_mgmt_act\fP +.IP "rt" 12 +Resource type to modify, see \fIenum nvme_virt_mgmt_rt\fP +.IP "cntlid" 12 +Controller id for which resources are bing modified +.IP "nr" 12 +Number of resources being allocated or assigned diff --git a/doc/man/nvme_write.2 b/doc/man/nvme_write.2 new file mode 100644 index 0000000..ca701a9 --- /dev/null +++ b/doc/man/nvme_write.2 @@ -0,0 +1,12 @@ +.TH "nvme_write" 9 "nvme_write" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_write \- Submit an nvme user write command +.SH SYNOPSIS +.B "int" nvme_write +.BI "(struct nvme_io_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_io_args\fP argument structure +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_write_uncorrectable.2 b/doc/man/nvme_write_uncorrectable.2 new file mode 100644 index 0000000..018f526 --- /dev/null +++ b/doc/man/nvme_write_uncorrectable.2 @@ -0,0 +1,17 @@ +.TH "nvme_write_uncorrectable" 9 "nvme_write_uncorrectable" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_write_uncorrectable \- Submit an nvme write uncorrectable command +.SH SYNOPSIS +.B "int" nvme_write_uncorrectable +.BI "(struct nvme_io_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_io_args\fP argument structure +.SH "DESCRIPTION" +The Write Uncorrectable command marks a range of logical blocks as invalid. +When the specified logical block(s) are read after this operation, a failure +is returned with Unrecovered Read Error status. To clear the invalid logical +block status, a write operation on those logical blocks is required. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_write_zeros.2 b/doc/man/nvme_write_zeros.2 new file mode 100644 index 0000000..26f17e0 --- /dev/null +++ b/doc/man/nvme_write_zeros.2 @@ -0,0 +1,17 @@ +.TH "nvme_write_zeros" 9 "nvme_write_zeros" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_write_zeros \- Submit an nvme write zeroes command +.SH SYNOPSIS +.B "int" nvme_write_zeros +.BI "(struct nvme_io_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_io_args\fP argument structure +.SH "DESCRIPTION" +The Write Zeroes command sets a range of logical blocks to zero. After +successful completion of this command, the value returned by subsequent +reads of logical blocks in this range shall be all bytes cleared to 0h until +a write occurs to this LBA range. +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_zns_append.2 b/doc/man/nvme_zns_append.2 new file mode 100644 index 0000000..ee381ea --- /dev/null +++ b/doc/man/nvme_zns_append.2 @@ -0,0 +1,12 @@ +.TH "nvme_zns_append" 9 "nvme_zns_append" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_zns_append \- Append data to a zone +.SH SYNOPSIS +.B "int" nvme_zns_append +.BI "(struct nvme_zns_append_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_zns_append_args\fP argument structure +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_zns_append_args.2 b/doc/man/nvme_zns_append_args.2 new file mode 100644 index 0000000..7c87dce --- /dev/null +++ b/doc/man/nvme_zns_append_args.2 @@ -0,0 +1,70 @@ +.TH "libnvme" 9 "struct nvme_zns_append_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_zns_append_args \- Arguments for the NVMe ZNS Append command +.SH SYNOPSIS +struct nvme_zns_append_args { +.br +.BI " __u64 zslba;" +.br +.BI " __u64 *result;" +.br +.BI " void *data;" +.br +.BI " void *metadata;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u32 nsid;" +.br +.BI " __u32 ilbrt;" +.br +.BI " __u32 data_len;" +.br +.BI " __u32 metadata_len;" +.br +.BI " __u16 nlb;" +.br +.BI " __u16 control;" +.br +.BI " __u16 lbat;" +.br +.BI " __u16 lbatm;" +.br +.BI " +}; +.br + +.SH Members +.IP "zslba" 12 +Zone start logical block address +.IP "result" 12 +The command completion result from CQE dword0 +.IP "data" 12 +Userspace address of the data +.IP "metadata" 12 +Userspace address of the metadata +.IP "args_size" 12 +Size of \fIstruct nvme_zns_append_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +Timeout in ms +.IP "nsid" 12 +Namespace ID +.IP "ilbrt" 12 +Initial logical block reference tag +.IP "data_len" 12 +Length of \fIdata\fP +.IP "metadata_len" 12 +Length of \fImetadata\fP +.IP "nlb" 12 +Number of logical blocks +.IP "control" 12 +.IP "lbat" 12 +Logical block application tag +.IP "lbatm" 12 +Logical block application tag mask diff --git a/doc/man/nvme_zns_changed_zone_log.2 b/doc/man/nvme_zns_changed_zone_log.2 new file mode 100644 index 0000000..31a9aef --- /dev/null +++ b/doc/man/nvme_zns_changed_zone_log.2 @@ -0,0 +1,23 @@ +.TH "libnvme" 9 "struct nvme_zns_changed_zone_log" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_zns_changed_zone_log \- ZNS Changed Zone List log +.SH SYNOPSIS +struct nvme_zns_changed_zone_log { +.br +.BI " __le16 nrzid;" +.br +.BI " __u8 rsvd2[6];" +.br +.BI " __le64 zid[NVME_ZNS_CHANGED_ZONES_MAX];" +.br +.BI " +}; +.br + +.SH Members +.IP "nrzid" 12 +Number of Zone Identifiers +.IP "rsvd2" 12 +Reserved +.IP "zid" 12 +Zone Identifier diff --git a/doc/man/nvme_zns_desc.2 b/doc/man/nvme_zns_desc.2 new file mode 100644 index 0000000..06bc3a4 --- /dev/null +++ b/doc/man/nvme_zns_desc.2 @@ -0,0 +1,47 @@ +.TH "libnvme" 9 "struct nvme_zns_desc" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_zns_desc \- +.SH SYNOPSIS +struct nvme_zns_desc { +.br +.BI " __u8 zt;" +.br +.BI " __u8 zs;" +.br +.BI " __u8 za;" +.br +.BI " __u8 zai;" +.br +.BI " __u8 rsvd4[4];" +.br +.BI " __le64 zcap;" +.br +.BI " __le64 zslba;" +.br +.BI " __le64 wp;" +.br +.BI " __u8 rsvd32[32];" +.br +.BI " +}; +.br + +.SH Members +.IP "zt" 12 +Zone Type +.IP "zs" 12 +Zone State +.IP "za" 12 +Zone Attributes +.IP "zai" 12 +Zone Attributes Information +.IP "rsvd4" 12 +Reserved +.IP "zcap" 12 +Zone Capacity +.IP "zslba" 12 +Zone Start Logical Block Address +.IP "wp" 12 +Write Pointer +.IP "rsvd32" 12 +Reserved diff --git a/doc/man/nvme_zns_id_ctrl.2 b/doc/man/nvme_zns_id_ctrl.2 new file mode 100644 index 0000000..fc0898f --- /dev/null +++ b/doc/man/nvme_zns_id_ctrl.2 @@ -0,0 +1,18 @@ +.TH "libnvme" 9 "struct nvme_zns_id_ctrl" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_zns_id_ctrl \- +.SH SYNOPSIS +struct nvme_zns_id_ctrl { +.br +.BI " __u8 zasl;" +.br +.BI " __u8 rsvd1[4095];" +.br +.BI " +}; +.br + +.SH Members +.IP "zasl" 12 +.IP "rsvd1" 12 +Reserved diff --git a/doc/man/nvme_zns_id_ns.2 b/doc/man/nvme_zns_id_ns.2 new file mode 100644 index 0000000..4e9ac06 --- /dev/null +++ b/doc/man/nvme_zns_id_ns.2 @@ -0,0 +1,87 @@ +.TH "libnvme" 9 "struct nvme_zns_id_ns" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_zns_id_ns \- Zoned Namespace Command Set Specific Identify Namespace Data Structure +.SH SYNOPSIS +struct nvme_zns_id_ns { +.br +.BI " __le16 zoc;" +.br +.BI " __le16 ozcs;" +.br +.BI " __le32 mar;" +.br +.BI " __le32 mor;" +.br +.BI " __le32 rrl;" +.br +.BI " __le32 frl;" +.br +.BI " __le32 rrl1;" +.br +.BI " __le32 rrl2;" +.br +.BI " __le32 rrl3;" +.br +.BI " __le32 frl1;" +.br +.BI " __le32 frl2;" +.br +.BI " __le32 frl3;" +.br +.BI " __le32 numzrwa;" +.br +.BI " __le16 zrwafg;" +.br +.BI " __le16 zrwasz;" +.br +.BI " __u8 zrwacap;" +.br +.BI " __u8 rsvd53[2763];" +.br +.BI " struct nvme_zns_lbafe lbafe[64];" +.br +.BI " __u8 vs[256];" +.br +.BI " +}; +.br + +.SH Members +.IP "zoc" 12 +Zone Operation Characteristics +.IP "ozcs" 12 +Optional Zoned Command Support +.IP "mar" 12 +Maximum Active Resources +.IP "mor" 12 +Maximum Open Resources +.IP "rrl" 12 +Reset Recommended Limit +.IP "frl" 12 +Finish Recommended Limit +.IP "rrl1" 12 +Reset Recommended Limit 1 +.IP "rrl2" 12 +Reset Recommended Limit 2 +.IP "rrl3" 12 +Reset Recommended Limit 3 +.IP "frl1" 12 +Finish Recommended Limit 1 +.IP "frl2" 12 +Finish Recommended Limit 2 +.IP "frl3" 12 +Finish Recommended Limit 3 +.IP "numzrwa" 12 +Number of ZRWA Resources +.IP "zrwafg" 12 +ZRWA Flush Granularity +.IP "zrwasz" 12 +ZRWA Size +.IP "zrwacap" 12 +ZRWA Capability +.IP "rsvd53" 12 +Reserved +.IP "lbafe" 12 +LBA Format Extension +.IP "vs" 12 +Vendor Specific diff --git a/doc/man/nvme_zns_identify_ctrl.2 b/doc/man/nvme_zns_identify_ctrl.2 new file mode 100644 index 0000000..bf3ebd3 --- /dev/null +++ b/doc/man/nvme_zns_identify_ctrl.2 @@ -0,0 +1,15 @@ +.TH "nvme_zns_identify_ctrl" 9 "nvme_zns_identify_ctrl" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_zns_identify_ctrl \- ZNS identify controller data +.SH SYNOPSIS +.B "int" nvme_zns_identify_ctrl +.BI "(int fd " "," +.BI "struct nvme_zns_id_ctrl *id " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "id" 12 +User space destination address to transfer the data +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_zns_identify_ns.2 b/doc/man/nvme_zns_identify_ns.2 new file mode 100644 index 0000000..4b95bb9 --- /dev/null +++ b/doc/man/nvme_zns_identify_ns.2 @@ -0,0 +1,18 @@ +.TH "nvme_zns_identify_ns" 9 "nvme_zns_identify_ns" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_zns_identify_ns \- ZNS identify namespace data +.SH SYNOPSIS +.B "int" nvme_zns_identify_ns +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "struct nvme_zns_id_ns *data " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Namespace to identify +.IP "data" 12 +User space destination address to transfer the data +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_zns_lbafe.2 b/doc/man/nvme_zns_lbafe.2 new file mode 100644 index 0000000..846d775 --- /dev/null +++ b/doc/man/nvme_zns_lbafe.2 @@ -0,0 +1,23 @@ +.TH "libnvme" 9 "struct nvme_zns_lbafe" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_zns_lbafe \- +.SH SYNOPSIS +struct nvme_zns_lbafe { +.br +.BI " __le64 zsze;" +.br +.BI " __u8 zdes;" +.br +.BI " __u8 rsvd9[7];" +.br +.BI " +}; +.br + +.SH Members +.IP "zsze" 12 +Zone Size +.IP "zdes" 12 +Zone Descriptor Extension Size +.IP "rsvd9" 12 +reserved diff --git a/doc/man/nvme_zns_mgmt_recv.2 b/doc/man/nvme_zns_mgmt_recv.2 new file mode 100644 index 0000000..222d828 --- /dev/null +++ b/doc/man/nvme_zns_mgmt_recv.2 @@ -0,0 +1,12 @@ +.TH "nvme_zns_mgmt_recv" 9 "nvme_zns_mgmt_recv" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_zns_mgmt_recv \- +.SH SYNOPSIS +.B "int" nvme_zns_mgmt_recv +.BI "(struct nvme_zns_mgmt_recv_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_zns_mgmt_recv_args\fP argument structure +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_zns_mgmt_recv_args.2 b/doc/man/nvme_zns_mgmt_recv_args.2 new file mode 100644 index 0000000..556b136 --- /dev/null +++ b/doc/man/nvme_zns_mgmt_recv_args.2 @@ -0,0 +1,55 @@ +.TH "libnvme" 9 "struct nvme_zns_mgmt_recv_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_zns_mgmt_recv_args \- Arguments for the NVMe ZNS Management Receive command +.SH SYNOPSIS +struct nvme_zns_mgmt_recv_args { +.br +.BI " __u64 slba;" +.br +.BI " __u32 *result;" +.br +.BI " void *data;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u32 nsid;" +.br +.BI " enum nvme_zns_recv_action zra;" +.br +.BI " __u32 data_len;" +.br +.BI " __u16 zrasf;" +.br +.BI " bool zras_feat;" +.br +.BI " +}; +.br + +.SH Members +.IP "slba" 12 +Starting logical block address +.IP "result" 12 +The command completion result from CQE dword0 +.IP "data" 12 +Userspace address of the data +.IP "args_size" 12 +Size of \fIstruct nvme_zns_mgmt_recv_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +timeout in ms +.IP "nsid" 12 +Namespace ID +.IP "zra" 12 +zone receive action +.IP "data_len" 12 +Length of \fIdata\fP +.IP "zrasf" 12 +Zone receive action specific field +.IP "zras_feat" 12 +Zone receive action specific features diff --git a/doc/man/nvme_zns_mgmt_send.2 b/doc/man/nvme_zns_mgmt_send.2 new file mode 100644 index 0000000..e91a032 --- /dev/null +++ b/doc/man/nvme_zns_mgmt_send.2 @@ -0,0 +1,12 @@ +.TH "nvme_zns_mgmt_send" 9 "nvme_zns_mgmt_send" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_zns_mgmt_send \- +.SH SYNOPSIS +.B "int" nvme_zns_mgmt_send +.BI "(struct nvme_zns_mgmt_send_args *args " ");" +.SH ARGUMENTS +.IP "args" 12 +\fIstruct nvme_zns_mgmt_send_args\fP argument structure +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_zns_mgmt_send_args.2 b/doc/man/nvme_zns_mgmt_send_args.2 new file mode 100644 index 0000000..0b1b53c --- /dev/null +++ b/doc/man/nvme_zns_mgmt_send_args.2 @@ -0,0 +1,55 @@ +.TH "libnvme" 9 "struct nvme_zns_mgmt_send_args" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_zns_mgmt_send_args \- Arguments for the NVMe ZNS Management Send command +.SH SYNOPSIS +struct nvme_zns_mgmt_send_args { +.br +.BI " __u64 slba;" +.br +.BI " __u32 *result;" +.br +.BI " void *data;" +.br +.BI " int args_size;" +.br +.BI " int fd;" +.br +.BI " __u32 timeout;" +.br +.BI " __u32 nsid;" +.br +.BI " enum nvme_zns_send_action zsa;" +.br +.BI " __u32 data_len;" +.br +.BI " bool select_all;" +.br +.BI " __u8 zsaso;" +.br +.BI " +}; +.br + +.SH Members +.IP "slba" 12 +Starting logical block address +.IP "result" 12 +The command completion result from CQE dword0 +.IP "data" 12 +Userspace address of the data +.IP "args_size" 12 +Size of \fIstruct nvme_zns_mgmt_send_args\fP +.IP "fd" 12 +File descriptor of nvme device +.IP "timeout" 12 +timeout in ms +.IP "nsid" 12 +Namespace ID +.IP "zsa" 12 +Zone send action +.IP "data_len" 12 +Length of \fIdata\fP +.IP "select_all" 12 +Select all flag +.IP "zsaso" 12 +Zone Send Action Specific Option diff --git a/doc/man/nvme_zns_recv_action.2 b/doc/man/nvme_zns_recv_action.2 new file mode 100644 index 0000000..a14d83e --- /dev/null +++ b/doc/man/nvme_zns_recv_action.2 @@ -0,0 +1,18 @@ +.TH "libnvme" 9 "enum nvme_zns_recv_action" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_zns_recv_action \- +.SH SYNOPSIS +enum nvme_zns_recv_action { +.br +.BI " NVME_ZNS_ZRA_REPORT_ZONES" +, +.br +.br +.BI " NVME_ZNS_ZRA_EXTENDED_REPORT_ZONES" + +}; +.SH Constants +.IP "NVME_ZNS_ZRA_REPORT_ZONES" 12 +Report Zones +.IP "NVME_ZNS_ZRA_EXTENDED_REPORT_ZONES" 12 +Extended Report Zones diff --git a/doc/man/nvme_zns_report_options.2 b/doc/man/nvme_zns_report_options.2 new file mode 100644 index 0000000..f938ffd --- /dev/null +++ b/doc/man/nvme_zns_report_options.2 @@ -0,0 +1,54 @@ +.TH "libnvme" 9 "enum nvme_zns_report_options" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_zns_report_options \- +.SH SYNOPSIS +enum nvme_zns_report_options { +.br +.BI " NVME_ZNS_ZRAS_REPORT_ALL" +, +.br +.br +.BI " NVME_ZNS_ZRAS_REPORT_EMPTY" +, +.br +.br +.BI " NVME_ZNS_ZRAS_REPORT_IMPL_OPENED" +, +.br +.br +.BI " NVME_ZNS_ZRAS_REPORT_EXPL_OPENED" +, +.br +.br +.BI " NVME_ZNS_ZRAS_REPORT_CLOSED" +, +.br +.br +.BI " NVME_ZNS_ZRAS_REPORT_FULL" +, +.br +.br +.BI " NVME_ZNS_ZRAS_REPORT_READ_ONLY" +, +.br +.br +.BI " NVME_ZNS_ZRAS_REPORT_OFFLINE" + +}; +.SH Constants +.IP "NVME_ZNS_ZRAS_REPORT_ALL" 12 +List all zones +.IP "NVME_ZNS_ZRAS_REPORT_EMPTY" 12 +List the zones in the ZSE:Empty state +.IP "NVME_ZNS_ZRAS_REPORT_IMPL_OPENED" 12 +List the zones in the ZSIO:Implicitly Opened state +.IP "NVME_ZNS_ZRAS_REPORT_EXPL_OPENED" 12 +List the zones in the ZSEO:Explicitly Opened state +.IP "NVME_ZNS_ZRAS_REPORT_CLOSED" 12 +List the zones in the ZSC:Closed state +.IP "NVME_ZNS_ZRAS_REPORT_FULL" 12 +List the zones in the ZSF:Full state +.IP "NVME_ZNS_ZRAS_REPORT_READ_ONLY" 12 +List the zones in the ZSRO:Read Only state +.IP "NVME_ZNS_ZRAS_REPORT_OFFLINE" 12 +List the zones in the ZSO:Offline state diff --git a/doc/man/nvme_zns_report_zones.2 b/doc/man/nvme_zns_report_zones.2 new file mode 100644 index 0000000..6d61605 --- /dev/null +++ b/doc/man/nvme_zns_report_zones.2 @@ -0,0 +1,39 @@ +.TH "nvme_zns_report_zones" 9 "nvme_zns_report_zones" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvme_zns_report_zones \- Return the list of zones +.SH SYNOPSIS +.B "int" nvme_zns_report_zones +.BI "(int fd " "," +.BI "__u32 nsid " "," +.BI "__u64 slba " "," +.BI "enum nvme_zns_report_options opts " "," +.BI "bool extended " "," +.BI "bool partial " "," +.BI "__u32 data_len " "," +.BI "void *data " "," +.BI "__u32 timeout " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "fd" 12 +File descriptor of nvme device +.IP "nsid" 12 +Namespace ID +.IP "slba" 12 +Starting LBA +.IP "opts" 12 +Reporting options +.IP "extended" 12 +Extended report +.IP "partial" 12 +Partial report requested +.IP "data_len" 12 +Length of the data buffer +.IP "data" 12 +Userspace address of the report zones data +.IP "timeout" 12 +timeout in ms +.IP "result" 12 +The command completion result from CQE dword0 +.SH "RETURN" +The nvme command status if a response was received (see +\fIenum nvme_status_field\fP) or -1 with errno set otherwise. diff --git a/doc/man/nvme_zns_send_action.2 b/doc/man/nvme_zns_send_action.2 new file mode 100644 index 0000000..0c13f63 --- /dev/null +++ b/doc/man/nvme_zns_send_action.2 @@ -0,0 +1,48 @@ +.TH "libnvme" 9 "enum nvme_zns_send_action" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_zns_send_action \- +.SH SYNOPSIS +enum nvme_zns_send_action { +.br +.BI " NVME_ZNS_ZSA_CLOSE" +, +.br +.br +.BI " NVME_ZNS_ZSA_FINISH" +, +.br +.br +.BI " NVME_ZNS_ZSA_OPEN" +, +.br +.br +.BI " NVME_ZNS_ZSA_RESET" +, +.br +.br +.BI " NVME_ZNS_ZSA_OFFLINE" +, +.br +.br +.BI " NVME_ZNS_ZSA_SET_DESC_EXT" +, +.br +.br +.BI " NVME_ZNS_ZSA_ZRWA_FLUSH" + +}; +.SH Constants +.IP "NVME_ZNS_ZSA_CLOSE" 12 +Close Zone +.IP "NVME_ZNS_ZSA_FINISH" 12 +Finish Zone +.IP "NVME_ZNS_ZSA_OPEN" 12 +Open Zone +.IP "NVME_ZNS_ZSA_RESET" 12 +Reset Zone +.IP "NVME_ZNS_ZSA_OFFLINE" 12 +Offline Zone +.IP "NVME_ZNS_ZSA_SET_DESC_EXT" 12 +Set Zone Descriptor Extension +.IP "NVME_ZNS_ZSA_ZRWA_FLUSH" 12 +Flush diff --git a/doc/man/nvme_zns_za.2 b/doc/man/nvme_zns_za.2 new file mode 100644 index 0000000..ab9cb27 --- /dev/null +++ b/doc/man/nvme_zns_za.2 @@ -0,0 +1,35 @@ +.TH "libnvme" 9 "enum nvme_zns_za" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_zns_za \- +.SH SYNOPSIS +enum nvme_zns_za { +.br +.BI " NVME_ZNS_ZA_ZFC" +, +.br +.br +.BI " NVME_ZNS_ZA_FZR" +, +.br +.br +.BI " NVME_ZNS_ZA_RZR" +, +.br +.br +.BI " NVME_ZNS_ZA_ZRWAV" +, +.br +.br +.BI " NVME_ZNS_ZA_ZDEV" + +}; +.SH Constants +.IP "NVME_ZNS_ZA_ZFC" 12 +Zone Finished by Controller +.IP "NVME_ZNS_ZA_FZR" 12 +Finish Zone Recommended +.IP "NVME_ZNS_ZA_RZR" 12 +Reset Zone Recommended +.IP "NVME_ZNS_ZA_ZRWAV" 12 +.IP "NVME_ZNS_ZA_ZDEV" 12 +Zone Descriptor Extension Valid diff --git a/doc/man/nvme_zns_zs.2 b/doc/man/nvme_zns_zs.2 new file mode 100644 index 0000000..ee0d193 --- /dev/null +++ b/doc/man/nvme_zns_zs.2 @@ -0,0 +1,48 @@ +.TH "libnvme" 9 "enum nvme_zns_zs" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_zns_zs \- +.SH SYNOPSIS +enum nvme_zns_zs { +.br +.BI " NVME_ZNS_ZS_EMPTY" +, +.br +.br +.BI " NVME_ZNS_ZS_IMPL_OPEN" +, +.br +.br +.BI " NVME_ZNS_ZS_EXPL_OPEN" +, +.br +.br +.BI " NVME_ZNS_ZS_CLOSED" +, +.br +.br +.BI " NVME_ZNS_ZS_READ_ONLY" +, +.br +.br +.BI " NVME_ZNS_ZS_FULL" +, +.br +.br +.BI " NVME_ZNS_ZS_OFFLINE" + +}; +.SH Constants +.IP "NVME_ZNS_ZS_EMPTY" 12 +Empty state +.IP "NVME_ZNS_ZS_IMPL_OPEN" 12 +Implicitly open state +.IP "NVME_ZNS_ZS_EXPL_OPEN" 12 +Explicitly open state +.IP "NVME_ZNS_ZS_CLOSED" 12 +Closed state +.IP "NVME_ZNS_ZS_READ_ONLY" 12 +Read only state +.IP "NVME_ZNS_ZS_FULL" 12 +Full state +.IP "NVME_ZNS_ZS_OFFLINE" 12 +Offline state diff --git a/doc/man/nvme_zns_zt.2 b/doc/man/nvme_zns_zt.2 new file mode 100644 index 0000000..97b1291 --- /dev/null +++ b/doc/man/nvme_zns_zt.2 @@ -0,0 +1,11 @@ +.TH "libnvme" 9 "enum nvme_zns_zt" "April 2022" "API Manual" LINUX +.SH NAME +enum nvme_zns_zt \- +.SH SYNOPSIS +enum nvme_zns_zt { +.br +.BI " NVME_ZONE_TYPE_SEQWRITE_REQ" + +}; +.SH Constants +.IP "NVME_ZONE_TYPE_SEQWRITE_REQ" 12 diff --git a/doc/man/nvme_zone_report.2 b/doc/man/nvme_zone_report.2 new file mode 100644 index 0000000..26a3495 --- /dev/null +++ b/doc/man/nvme_zone_report.2 @@ -0,0 +1,23 @@ +.TH "libnvme" 9 "struct nvme_zone_report" "April 2022" "API Manual" LINUX +.SH NAME +struct nvme_zone_report \- +.SH SYNOPSIS +struct nvme_zone_report { +.br +.BI " __le64 nr_zones;" +.br +.BI " __u8 rsvd8[56];" +.br +.BI " struct nvme_zns_desc entries[];" +.br +.BI " +}; +.br + +.SH Members +.IP "nr_zones" 12 +Number of descriptors in \fIentries\fP +.IP "rsvd8" 12 +Reserved +.IP "entries" 12 +Zoned namespace descriptors diff --git a/doc/man/nvmf_add_ctrl.2 b/doc/man/nvmf_add_ctrl.2 new file mode 100644 index 0000000..d4ac1ac --- /dev/null +++ b/doc/man/nvmf_add_ctrl.2 @@ -0,0 +1,21 @@ +.TH "nvmf_add_ctrl" 9 "nvmf_add_ctrl" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvmf_add_ctrl \- Connect a controller and update topology +.SH SYNOPSIS +.B "int" nvmf_add_ctrl +.BI "(nvme_host_t h " "," +.BI "nvme_ctrl_t c " "," +.BI "const struct nvme_fabrics_config *cfg " ");" +.SH ARGUMENTS +.IP "h" 12 +Host to which the controller should be attached +.IP "c" 12 +Controller to be connected +.IP "cfg" 12 +Default configuration for the controller +.SH "DESCRIPTION" +Issues a 'connect' command to the NVMe-oF controller and inserts \fIc\fP +into the topology using \fIh\fP as parent. +\fIc\fP must be initialized and not connected to the topology. +.SH "RETURN" +0 on success; on failure errno is set and -1 is returned. diff --git a/doc/man/nvmf_addr_family.2 b/doc/man/nvmf_addr_family.2 new file mode 100644 index 0000000..333509c --- /dev/null +++ b/doc/man/nvmf_addr_family.2 @@ -0,0 +1,43 @@ +.TH "libnvme" 9 "enum nvmf_addr_family" "April 2022" "API Manual" LINUX +.SH NAME +enum nvmf_addr_family \- Address Family codes for Discovery Log Page entry ADRFAM field +.SH SYNOPSIS +enum nvmf_addr_family { +.br +.BI " NVMF_ADDR_FAMILY_PCI" +, +.br +.br +.BI " NVMF_ADDR_FAMILY_IP4" +, +.br +.br +.BI " NVMF_ADDR_FAMILY_IP6" +, +.br +.br +.BI " NVMF_ADDR_FAMILY_IB" +, +.br +.br +.BI " NVMF_ADDR_FAMILY_FC" +, +.br +.br +.BI " NVMF_ADDR_FAMILY_LOOP" + +}; +.SH Constants +.IP "NVMF_ADDR_FAMILY_PCI" 12 +PCIe +.IP "NVMF_ADDR_FAMILY_IP4" 12 +AF_INET: IPv4 address family. +.IP "NVMF_ADDR_FAMILY_IP6" 12 +AF_INET6: IPv6 address family. +.IP "NVMF_ADDR_FAMILY_IB" 12 +AF_IB: InfiniBand address family. +.IP "NVMF_ADDR_FAMILY_FC" 12 +Fibre Channel address family. +.IP "NVMF_ADDR_FAMILY_LOOP" 12 +Intra-host Transport (i.e., loopback), reserved +for host usage. diff --git a/doc/man/nvmf_adrfam_str.2 b/doc/man/nvmf_adrfam_str.2 new file mode 100644 index 0000000..d58dc90 --- /dev/null +++ b/doc/man/nvmf_adrfam_str.2 @@ -0,0 +1,14 @@ +.TH "nvmf_adrfam_str" 9 "nvmf_adrfam_str" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvmf_adrfam_str \- Decode ADRFAM field +.SH SYNOPSIS +.B "const char *" nvmf_adrfam_str +.BI "(__u8 adrfam " ");" +.SH ARGUMENTS +.IP "adrfam" 12 +value to be decoded +.SH "DESCRIPTION" +Decode the address family field in the discovery +log page entry. +.SH "RETURN" +decoded string diff --git a/doc/man/nvmf_cms_str.2 b/doc/man/nvmf_cms_str.2 new file mode 100644 index 0000000..dffcf85 --- /dev/null +++ b/doc/man/nvmf_cms_str.2 @@ -0,0 +1,14 @@ +.TH "nvmf_cms_str" 9 "nvmf_cms_str" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvmf_cms_str \- Decode RDMA connection management service field +.SH SYNOPSIS +.B "const char *" nvmf_cms_str +.BI "(__u8 cms " ");" +.SH ARGUMENTS +.IP "cms" 12 +value to be decoded +.SH "DESCRIPTION" +Decode the RDMA connection management service field in the discovery +log page entry. +.SH "RETURN" +decoded string diff --git a/doc/man/nvmf_connect_data.2 b/doc/man/nvmf_connect_data.2 new file mode 100644 index 0000000..6164c0a --- /dev/null +++ b/doc/man/nvmf_connect_data.2 @@ -0,0 +1,35 @@ +.TH "libnvme" 9 "struct nvmf_connect_data" "April 2022" "API Manual" LINUX +.SH NAME +struct nvmf_connect_data \- Data payload for the 'connect' command +.SH SYNOPSIS +struct nvmf_connect_data { +.br +.BI " __u8 hostid[16];" +.br +.BI " __le16 cntlid;" +.br +.BI " char rsvd4[238];" +.br +.BI " char subsysnqn[NVME_NQN_LENGTH];" +.br +.BI " char hostnqn[NVME_NQN_LENGTH];" +.br +.BI " char rsvd5[256];" +.br +.BI " +}; +.br + +.SH Members +.IP "hostid" 12 +Host ID of the connecting host +.IP "cntlid" 12 +Requested controller ID +.IP "rsvd4" 12 +Reserved +.IP "subsysnqn" 12 +Subsystem NQN to connect to +.IP "hostnqn" 12 +Host NQN of the connecting host +.IP "rsvd5" 12 +Reserved diff --git a/doc/man/nvmf_connect_disc_entry.2 b/doc/man/nvmf_connect_disc_entry.2 new file mode 100644 index 0000000..dd15474 --- /dev/null +++ b/doc/man/nvmf_connect_disc_entry.2 @@ -0,0 +1,20 @@ +.TH "nvmf_connect_disc_entry" 9 "nvmf_connect_disc_entry" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvmf_connect_disc_entry \- Connect controller based on the discovery log page entry +.SH SYNOPSIS +.B "nvme_ctrl_t" nvmf_connect_disc_entry +.BI "(nvme_host_t h " "," +.BI "struct nvmf_disc_log_entry *e " "," +.BI "const struct nvme_fabrics_config *defcfg " "," +.BI "bool *discover " ");" +.SH ARGUMENTS +.IP "h" 12 +Host to which the controller should be connected +.IP "e" 12 +Discovery log page entry +.IP "defcfg" 12 +Default configurationn to be used for the new controller +.IP "discover" 12 +Set to 'true' if the new controller is a discovery controller +.SH "RETURN" +Pointer to the new controller diff --git a/doc/man/nvmf_default_config.2 b/doc/man/nvmf_default_config.2 new file mode 100644 index 0000000..3b958db --- /dev/null +++ b/doc/man/nvmf_default_config.2 @@ -0,0 +1,11 @@ +.TH "nvmf_default_config" 9 "nvmf_default_config" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvmf_default_config \- Default values for fabrics configuration +.SH SYNOPSIS +.B "void" nvmf_default_config +.BI "(struct nvme_fabrics_config *cfg " ");" +.SH ARGUMENTS +.IP "cfg" 12 +config values to set +.SH "DESCRIPTION" +Initializes \fIcfg\fP with default values. diff --git a/doc/man/nvmf_dim_data.2 b/doc/man/nvmf_dim_data.2 new file mode 100644 index 0000000..85d2be9 --- /dev/null +++ b/doc/man/nvmf_dim_data.2 @@ -0,0 +1,63 @@ +.TH "libnvme" 9 "struct nvmf_dim_data" "April 2022" "API Manual" LINUX +.SH NAME +struct nvmf_dim_data \- Discovery Information Management (DIM) - Data +.SH SYNOPSIS +struct nvmf_dim_data { +.br +.BI " __le32 tdl;" +.br +.BI " __u8 rsvd4[4];" +.br +.BI " __le64 nument;" +.br +.BI " __le16 entfmt;" +.br +.BI " __le16 etype;" +.br +.BI " __u8 portlcl;" +.br +.BI " __u8 rsvd21;" +.br +.BI " __le16 ektype;" +.br +.BI " char eid[NVME_NQN_LENGTH];" +.br +.BI " char ename[NVMF_ENAME_LEN];" +.br +.BI " char ever[NVMF_EVER_LEN];" +.br +.BI " __u8 rsvd600[424];" +.br +.BI " union nvmf_die die[];" +.br +.BI " +}; +.br + +.SH Members +.IP "tdl" 12 +Total Data Length +.IP "rsvd4" 12 +Reserved +.IP "nument" 12 +Number of entries +.IP "entfmt" 12 +Entry Format (\fIenum nvmf_dim_entfmt\fP) +.IP "etype" 12 +Entity Type (\fIenum nvmf_dim_etype\fP) +.IP "portlcl" 12 +Port Local +.IP "rsvd21" 12 +Reserved +.IP "ektype" 12 +Entry Key Type +.IP "eid" 12 +Entity Identifier (e.g. Host NQN) +.IP "ename" 12 +Entity Name (e.g. hostname) +.IP "ever" 12 +Entity Version (e.g. OS Name/Version) +.IP "rsvd600" 12 +Reserved +.IP "die" 12 +Discovery Information Entry (see \fInument\fP above) diff --git a/doc/man/nvmf_dim_entfmt.2 b/doc/man/nvmf_dim_entfmt.2 new file mode 100644 index 0000000..b0903fd --- /dev/null +++ b/doc/man/nvmf_dim_entfmt.2 @@ -0,0 +1,18 @@ +.TH "libnvme" 9 "enum nvmf_dim_entfmt" "April 2022" "API Manual" LINUX +.SH NAME +enum nvmf_dim_entfmt \- Discovery Information Management Entry Format +.SH SYNOPSIS +enum nvmf_dim_entfmt { +.br +.BI " NVMF_DIM_ENTFMT_BASIC" +, +.br +.br +.BI " NVMF_DIM_ENTFMT_EXTENDED" + +}; +.SH Constants +.IP "NVMF_DIM_ENTFMT_BASIC" 12 +Basic discovery information entry +.IP "NVMF_DIM_ENTFMT_EXTENDED" 12 +Extended discovery information entry diff --git a/doc/man/nvmf_dim_etype.2 b/doc/man/nvmf_dim_etype.2 new file mode 100644 index 0000000..4f3a9eb --- /dev/null +++ b/doc/man/nvmf_dim_etype.2 @@ -0,0 +1,24 @@ +.TH "libnvme" 9 "enum nvmf_dim_etype" "April 2022" "API Manual" LINUX +.SH NAME +enum nvmf_dim_etype \- Discovery Information Management Entity Type +.SH SYNOPSIS +enum nvmf_dim_etype { +.br +.BI " NVMF_DIM_ETYPE_HOST" +, +.br +.br +.BI " NVMF_DIM_ETYPE_DDC" +, +.br +.br +.BI " NVMF_DIM_ETYPE_CDC" + +}; +.SH Constants +.IP "NVMF_DIM_ETYPE_HOST" 12 +Host +.IP "NVMF_DIM_ETYPE_DDC" 12 +Direct Discovery controller +.IP "NVMF_DIM_ETYPE_CDC" 12 +Centralized Discovery controller diff --git a/doc/man/nvmf_dim_tas.2 b/doc/man/nvmf_dim_tas.2 new file mode 100644 index 0000000..156a7da --- /dev/null +++ b/doc/man/nvmf_dim_tas.2 @@ -0,0 +1,24 @@ +.TH "libnvme" 9 "enum nvmf_dim_tas" "April 2022" "API Manual" LINUX +.SH NAME +enum nvmf_dim_tas \- Discovery Information Management Task +.SH SYNOPSIS +enum nvmf_dim_tas { +.br +.BI " NVMF_DIM_TAS_REGISTER" +, +.br +.br +.BI " NVMF_DIM_TAS_DEREGISTER" +, +.br +.br +.BI " NVMF_DIM_TAS_UPDATE" + +}; +.SH Constants +.IP "NVMF_DIM_TAS_REGISTER" 12 +Register +.IP "NVMF_DIM_TAS_DEREGISTER" 12 +Deregister +.IP "NVMF_DIM_TAS_UPDATE" 12 +Update diff --git a/doc/man/nvmf_disc_eflags.2 b/doc/man/nvmf_disc_eflags.2 new file mode 100644 index 0000000..60f4ba3 --- /dev/null +++ b/doc/man/nvmf_disc_eflags.2 @@ -0,0 +1,39 @@ +.TH "libnvme" 9 "enum nvmf_disc_eflags" "April 2022" "API Manual" LINUX +.SH NAME +enum nvmf_disc_eflags \- Discovery Log Page entry flags. +.SH SYNOPSIS +enum nvmf_disc_eflags { +.br +.BI " NVMF_DISC_EFLAGS_NONE" +, +.br +.br +.BI " NVMF_DISC_EFLAGS_DUPRETINFO" +, +.br +.br +.BI " NVMF_DISC_EFLAGS_EPCSD" +, +.br +.br +.BI " NVMF_DISC_EFLAGS_BOTH" + +}; +.SH Constants +.IP "NVMF_DISC_EFLAGS_NONE" 12 +Indicates that none of the DUPRETINFO or EPCSD +features are supported. +.IP "NVMF_DISC_EFLAGS_DUPRETINFO" 12 +Duplicate Returned Information (DUPRETINFO): +Indicates that using the content of this entry +to access this Discovery Service returns the same +information that is returned by using the content +of other entries in this log page that also have +this flag set. +.IP "NVMF_DISC_EFLAGS_EPCSD" 12 +Explicit Persistent Connection Support for Discovery (EPCSD): +Indicates that Explicit Persistent Connections are +supported for the Discovery controller. +.IP "NVMF_DISC_EFLAGS_BOTH" 12 +Indicates that both the DUPRETINFO and EPCSD +features are supported. diff --git a/doc/man/nvmf_disc_log_entry.2 b/doc/man/nvmf_disc_log_entry.2 new file mode 100644 index 0000000..73ef858 --- /dev/null +++ b/doc/man/nvmf_disc_log_entry.2 @@ -0,0 +1,96 @@ +.TH "libnvme" 9 "struct nvmf_disc_log_entry" "April 2022" "API Manual" LINUX +.SH NAME +struct nvmf_disc_log_entry \- Discovery Log Page entry +.SH SYNOPSIS +struct nvmf_disc_log_entry { +.br +.BI " __u8 trtype;" +.br +.BI " __u8 adrfam;" +.br +.BI " __u8 subtype;" +.br +.BI " __u8 treq;" +.br +.BI " __le16 portid;" +.br +.BI " __le16 cntlid;" +.br +.BI " __le16 asqsz;" +.br +.BI " __le16 eflags;" +.br +.BI " __u8 rsvd12[20];" +.br +.BI " char trsvcid[NVMF_TRSVCID_SIZE];" +.br +.BI " __u8 rsvd64[192];" +.br +.BI " char subnqn[NVME_NQN_LENGTH];" +.br +.BI " char traddr[NVMF_TRADDR_SIZE];" +.br +.BI " union nvmf_tsas tsas;" +.br +.BI " +}; +.br + +.SH Members +.IP "trtype" 12 +Transport Type (TRTYPE): Specifies the NVMe Transport type. +See \fIenum nvmf_trtype\fP. +.IP "adrfam" 12 +Address Family (ADRFAM): Specifies the address family. +See \fIenum nvmf_addr_family\fP. +.IP "subtype" 12 +Subsystem Type (SUBTYPE): Specifies the type of the NVM subsystem +that is indicated in this entry. See \fIenum nvme_subsys_type\fP. +.IP "treq" 12 +Transport Requirements (TREQ): Indicates requirements for the NVMe +Transport. See \fIenum nvmf_treq\fP. +.IP "portid" 12 +Port ID (PORTID): Specifies a particular NVM subsystem port. +Different NVMe Transports or address families may utilize the same +Port ID value (e.g. a Port ID may support both iWARP and RoCE). +.IP "cntlid" 12 +Controller ID (CNTLID): Specifies the controller ID. If the NVM +subsystem uses a dynamic controller model, then this field shall +be set to FFFFh. If the NVM subsystem uses a static controller model, +then this field may be set to a specific controller ID (values 0h +to FFEFh are valid). If the NVM subsystem uses a static controller +model and the value indicated is FFFEh, then the host should remember +the Controller ID returned as part of the Fabrics Connect command +in order to re-establish an association in the future with the same +controller. +.IP "asqsz" 12 +Admin Max SQ Size (ASQSZ): Specifies the maximum size of an Admin +Submission Queue. This applies to all controllers in the NVM +subsystem. The value shall be a minimum of 32 entries. +.IP "eflags" 12 +Entry Flags (EFLAGS): Indicates additional information related to +the current entry. See \fIenum nvmf_disc_eflags\fP. +.IP "rsvd12" 12 +Reserved +.IP "trsvcid" 12 +Transport Service Identifier (TRSVCID): Specifies the NVMe Transport +service identifier as an ASCII string. The NVMe Transport service +identifier is specified by the associated NVMe Transport binding +specification. +.IP "rsvd64" 12 +Reserved +.IP "subnqn" 12 +NVM Subsystem Qualified Name (SUBNQN): NVMe Qualified Name (NQN) +that uniquely identifies the NVM subsystem. For a subsystem, if that +Discovery subsystem has a unique NQN (i.e., the NVM Subsystem NVMe +Qualified Name (SUBNQN) field in that Discovery subsystem's Identify +Controller data structure contains a unique NQN value), then the +value returned shall be that unique NQN. If the Discovery subsystem +does not have a unique NQN, then the value returned shall be the +well-known Discovery Service NQN (nqn.2014-08.org.nvmexpress.discovery). +.IP "traddr" 12 +Transport Address (TRADDR): Specifies the address of the NVM subsystem +that may be used for a Connect command as an ASCII string. The +Address Family field describes the reference for parsing this field. +.IP "tsas" 12 +Transport specific attribute settings diff --git a/doc/man/nvmf_discovery_log.2 b/doc/man/nvmf_discovery_log.2 new file mode 100644 index 0000000..f8707c1 --- /dev/null +++ b/doc/man/nvmf_discovery_log.2 @@ -0,0 +1,38 @@ +.TH "libnvme" 9 "struct nvmf_discovery_log" "April 2022" "API Manual" LINUX +.SH NAME +struct nvmf_discovery_log \- Discovery Log Page (Log Identifier 70h) +.SH SYNOPSIS +struct nvmf_discovery_log { +.br +.BI " __le64 genctr;" +.br +.BI " __le64 numrec;" +.br +.BI " __le16 recfmt;" +.br +.BI " __u8 rsvd14[1006];" +.br +.BI " struct nvmf_disc_log_entry entries[];" +.br +.BI " +}; +.br + +.SH Members +.IP "genctr" 12 +Generation Counter (GENCTR): Indicates the version of the discovery +information, starting at a value of 0h. For each change in the +Discovery Log Page, this counter is incremented by one. If the value +of this field is FFFFFFFF_FFFFFFFFh, then the field shall be cleared +to 0h when incremented (i.e., rolls over to 0h). +.IP "numrec" 12 +Number of Records (NUMREC): Indicates the number of records +contained in the log. +.IP "recfmt" 12 +Record Format (RECFMT): Specifies the format of the Discovery Log +Page. If a new format is defined, this value is incremented by one. +The format of the record specified in this definition shall be 0h. +.IP "rsvd14" 12 +Reserved +.IP "entries" 12 +Discovery Log Page Entries - see \fIstruct nvmf_disc_log_entry\fP. diff --git a/doc/man/nvmf_eflags_str.2 b/doc/man/nvmf_eflags_str.2 new file mode 100644 index 0000000..dbe1065 --- /dev/null +++ b/doc/man/nvmf_eflags_str.2 @@ -0,0 +1,14 @@ +.TH "nvmf_eflags_str" 9 "nvmf_eflags_str" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvmf_eflags_str \- Decode EFLAGS field +.SH SYNOPSIS +.B "const char *" nvmf_eflags_str +.BI "(__u16 eflags " ");" +.SH ARGUMENTS +.IP "eflags" 12 +value to be decoded +.SH "DESCRIPTION" +Decode the EFLAGS field in the discovery log page +entry. +.SH "RETURN" +decoded string diff --git a/doc/man/nvmf_exat_len.2 b/doc/man/nvmf_exat_len.2 new file mode 100644 index 0000000..2daeaea --- /dev/null +++ b/doc/man/nvmf_exat_len.2 @@ -0,0 +1,15 @@ +.TH "nvmf_exat_len" 9 "nvmf_exat_len" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvmf_exat_len \- Return length rounded up by 4 +.SH SYNOPSIS +.B "__u16" nvmf_exat_len +.BI "(size_t val_len " ");" +.SH ARGUMENTS +.IP "val_len" 12 +Value lenght +.SH "DESCRIPTION" +Return the size in bytes, rounded to a multiple of 4 (e.g., size of +__u32), of the buffer needed to hold the exat value of size +\fIval_len\fP. +.SH "RETURN" +Lenght rounded up by 4 diff --git a/doc/man/nvmf_exattype.2 b/doc/man/nvmf_exattype.2 new file mode 100644 index 0000000..07d0a92 --- /dev/null +++ b/doc/man/nvmf_exattype.2 @@ -0,0 +1,18 @@ +.TH "libnvme" 9 "enum nvmf_exattype" "April 2022" "API Manual" LINUX +.SH NAME +enum nvmf_exattype \- Extended Attribute Type +.SH SYNOPSIS +enum nvmf_exattype { +.br +.BI " NVMF_EXATTYPE_HOSTID" +, +.br +.br +.BI " NVMF_EXATTYPE_SYMNAME" + +}; +.SH Constants +.IP "NVMF_EXATTYPE_HOSTID" 12 +Host Identifier +.IP "NVMF_EXATTYPE_SYMNAME" 12 +Symblic Name diff --git a/doc/man/nvmf_ext_attr.2 b/doc/man/nvmf_ext_attr.2 new file mode 100644 index 0000000..4215edc --- /dev/null +++ b/doc/man/nvmf_ext_attr.2 @@ -0,0 +1,24 @@ +.TH "libnvme" 9 "struct nvmf_ext_attr" "April 2022" "API Manual" LINUX +.SH NAME +struct nvmf_ext_attr \- Extended Attribute (EXAT) +.SH SYNOPSIS +struct nvmf_ext_attr { +.br +.BI " __le16 exattype;" +.br +.BI " __le16 exatlen;" +.br +.BI " __u8 exatval[];" +.br +.BI " +}; +.br + +.SH Members +.IP "exattype" 12 +Extended Attribute Type (EXATTYPE) - see \fIenum\fP nvmf_exattype +.IP "exatlen" 12 +Extended Attribute Length (EXATLEN) +.IP "exatval" 12 +Extended Attribute Value (EXATVAL) - size allocated for array +must be a multiple of 4 bytes diff --git a/doc/man/nvmf_ext_die.2 b/doc/man/nvmf_ext_die.2 new file mode 100644 index 0000000..4d50926 --- /dev/null +++ b/doc/man/nvmf_ext_die.2 @@ -0,0 +1,79 @@ +.TH "libnvme" 9 "struct nvmf_ext_die" "April 2022" "API Manual" LINUX +.SH NAME +struct nvmf_ext_die \- Extended Discovery Information Entry (DIE) +.SH SYNOPSIS +struct nvmf_ext_die { +.br +.BI " __u8 trtype;" +.br +.BI " __u8 adrfam;" +.br +.BI " __u8 subtype;" +.br +.BI " __u8 treq;" +.br +.BI " __le16 portid;" +.br +.BI " __le16 cntlid;" +.br +.BI " __le16 asqsz;" +.br +.BI " __u8 rsvd10[22];" +.br +.BI " char trsvcid[NVMF_TRSVCID_SIZE];" +.br +.BI " __u8 resv64[192];" +.br +.BI " char nqn[NVME_NQN_LENGTH];" +.br +.BI " char traddr[NVMF_TRADDR_SIZE];" +.br +.BI " union nvmf_tsas tsas;" +.br +.BI " __le32 tel;" +.br +.BI " __le16 numexat;" +.br +.BI " __u8 resv1030[2];" +.br +.BI " struct nvmf_ext_attr exat[];" +.br +.BI " +}; +.br + +.SH Members +.IP "trtype" 12 +Transport Type (\fIenum nvmf_trtype\fP) +.IP "adrfam" 12 +Address Family (\fIenum nvmf_addr_family\fP) +.IP "subtype" 12 +Subsystem Type (\fIenum nvme_subsys_type\fP) +.IP "treq" 12 +Transport Requirements (\fIenum nvmf_treq\fP) +.IP "portid" 12 +Port ID +.IP "cntlid" 12 +Controller ID +.IP "asqsz" 12 +Admin Max SQ Size +.IP "rsvd10" 12 +Reserved +.IP "trsvcid" 12 +Transport Service Identifier +.IP "resv64" 12 +Reserved +.IP "nqn" 12 +NVM Qualified Name +.IP "traddr" 12 +Transport Address +.IP "tsas" 12 +Transport Specific Address Subtype (\fIunion nvmf_tsas\fP) +.IP "tel" 12 +Total Entry Length +.IP "numexat" 12 +Number of Extended Attributes +.IP "resv1030" 12 +Reserved +.IP "exat" 12 +Extented Attributes 0 (\fIstruct nvmf_ext_attr\fP) diff --git a/doc/man/nvmf_get_discovery_log.2 b/doc/man/nvmf_get_discovery_log.2 new file mode 100644 index 0000000..aee9c17 --- /dev/null +++ b/doc/man/nvmf_get_discovery_log.2 @@ -0,0 +1,17 @@ +.TH "nvmf_get_discovery_log" 9 "nvmf_get_discovery_log" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvmf_get_discovery_log \- Return the discovery log page +.SH SYNOPSIS +.B "int" nvmf_get_discovery_log +.BI "(nvme_ctrl_t c " "," +.BI "struct nvmf_discovery_log **logp " "," +.BI "int max_retries " ");" +.SH ARGUMENTS +.IP "c" 12 +Discover controller to use +.IP "logp" 12 +Pointer to the log page to be returned +.IP "max_retries" 12 +maximum number of log page entries to be returned +.SH "RETURN" +0 on success; on failure -1 is returned and errno is set diff --git a/doc/man/nvmf_hostid_from_file.2 b/doc/man/nvmf_hostid_from_file.2 new file mode 100644 index 0000000..72e5002 --- /dev/null +++ b/doc/man/nvmf_hostid_from_file.2 @@ -0,0 +1,9 @@ +.TH "nvmf_hostid_from_file" 9 "nvmf_hostid_from_file" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvmf_hostid_from_file \- Reads the host identifier from the config default location in /etc/nvme/. +.SH SYNOPSIS +.B "char *" nvmf_hostid_from_file +.SH ARGUMENTS +.SH "RETURN" +The host identifier, or NULL if unsuccessful. If found, the caller +is responsible to free the string. diff --git a/doc/man/nvmf_hostnqn_from_file.2 b/doc/man/nvmf_hostnqn_from_file.2 new file mode 100644 index 0000000..ce84ae5 --- /dev/null +++ b/doc/man/nvmf_hostnqn_from_file.2 @@ -0,0 +1,9 @@ +.TH "nvmf_hostnqn_from_file" 9 "nvmf_hostnqn_from_file" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvmf_hostnqn_from_file \- Reads the host nvm qualified name from the config default location in /etc/nvme/ +.SH SYNOPSIS +.B "char *" nvmf_hostnqn_from_file +.SH ARGUMENTS +.SH "RETURN" +The host nqn, or NULL if unsuccessful. If found, the caller +is responsible to free the string. diff --git a/doc/man/nvmf_hostnqn_generate.2 b/doc/man/nvmf_hostnqn_generate.2 new file mode 100644 index 0000000..baa5c12 --- /dev/null +++ b/doc/man/nvmf_hostnqn_generate.2 @@ -0,0 +1,9 @@ +.TH "nvmf_hostnqn_generate" 9 "nvmf_hostnqn_generate" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvmf_hostnqn_generate \- Generate a machine specific host nqn +.SH SYNOPSIS +.B "char *" nvmf_hostnqn_generate +.SH ARGUMENTS +.SH "RETURN" +An nvm namespace qualified name string based on the machine +identifier, or NULL if not successful. diff --git a/doc/man/nvmf_prtype_str.2 b/doc/man/nvmf_prtype_str.2 new file mode 100644 index 0000000..fb33189 --- /dev/null +++ b/doc/man/nvmf_prtype_str.2 @@ -0,0 +1,14 @@ +.TH "nvmf_prtype_str" 9 "nvmf_prtype_str" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvmf_prtype_str \- Decode RDMA Provider type field +.SH SYNOPSIS +.B "const char *" nvmf_prtype_str +.BI "(__u8 prtype " ");" +.SH ARGUMENTS +.IP "prtype" 12 +value to be decoded +.SH "DESCRIPTION" +Decode the RDMA Provider type field in the discovery +log page entry. +.SH "RETURN" +decoded string diff --git a/doc/man/nvmf_qptype_str.2 b/doc/man/nvmf_qptype_str.2 new file mode 100644 index 0000000..f67f9f6 --- /dev/null +++ b/doc/man/nvmf_qptype_str.2 @@ -0,0 +1,14 @@ +.TH "nvmf_qptype_str" 9 "nvmf_qptype_str" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvmf_qptype_str \- Decode RDMA QP Service type field +.SH SYNOPSIS +.B "const char *" nvmf_qptype_str +.BI "(__u8 qptype " ");" +.SH ARGUMENTS +.IP "qptype" 12 +value to be decoded +.SH "DESCRIPTION" +Decode the RDMA QP Service type field in the discovery log page +entry. +.SH "RETURN" +decoded string diff --git a/doc/man/nvmf_rdma_cms.2 b/doc/man/nvmf_rdma_cms.2 new file mode 100644 index 0000000..0b4d2fe --- /dev/null +++ b/doc/man/nvmf_rdma_cms.2 @@ -0,0 +1,12 @@ +.TH "libnvme" 9 "enum nvmf_rdma_cms" "April 2022" "API Manual" LINUX +.SH NAME +enum nvmf_rdma_cms \- RDMA Connection Management Service Type codes for Discovery Log Page entry TSAS RDMA_CMS field +.SH SYNOPSIS +enum nvmf_rdma_cms { +.br +.BI " NVMF_RDMA_CMS_RDMA_CM" + +}; +.SH Constants +.IP "NVMF_RDMA_CMS_RDMA_CM" 12 +Sockets based endpoint addressing diff --git a/doc/man/nvmf_rdma_prtype.2 b/doc/man/nvmf_rdma_prtype.2 new file mode 100644 index 0000000..997fe6d --- /dev/null +++ b/doc/man/nvmf_rdma_prtype.2 @@ -0,0 +1,36 @@ +.TH "libnvme" 9 "enum nvmf_rdma_prtype" "April 2022" "API Manual" LINUX +.SH NAME +enum nvmf_rdma_prtype \- RDMA Provider Type codes for Discovery Log Page entry TSAS RDMA_PRTYPE field +.SH SYNOPSIS +enum nvmf_rdma_prtype { +.br +.BI " NVMF_RDMA_PRTYPE_NOT_SPECIFIED" +, +.br +.br +.BI " NVMF_RDMA_PRTYPE_IB" +, +.br +.br +.BI " NVMF_RDMA_PRTYPE_ROCE" +, +.br +.br +.BI " NVMF_RDMA_PRTYPE_ROCEV2" +, +.br +.br +.BI " NVMF_RDMA_PRTYPE_IWARP" + +}; +.SH Constants +.IP "NVMF_RDMA_PRTYPE_NOT_SPECIFIED" 12 +No Provider Specified +.IP "NVMF_RDMA_PRTYPE_IB" 12 +InfiniBand +.IP "NVMF_RDMA_PRTYPE_ROCE" 12 +InfiniBand RoCE +.IP "NVMF_RDMA_PRTYPE_ROCEV2" 12 +InfiniBand RoCEV2 +.IP "NVMF_RDMA_PRTYPE_IWARP" 12 +iWARP diff --git a/doc/man/nvmf_rdma_qptype.2 b/doc/man/nvmf_rdma_qptype.2 new file mode 100644 index 0000000..c6a01d7 --- /dev/null +++ b/doc/man/nvmf_rdma_qptype.2 @@ -0,0 +1,18 @@ +.TH "libnvme" 9 "enum nvmf_rdma_qptype" "April 2022" "API Manual" LINUX +.SH NAME +enum nvmf_rdma_qptype \- RDMA QP Service Type codes for Discovery Log Page entry TSAS RDMA_QPTYPE field +.SH SYNOPSIS +enum nvmf_rdma_qptype { +.br +.BI " NVMF_RDMA_QPTYPE_CONNECTED" +, +.br +.br +.BI " NVMF_RDMA_QPTYPE_DATAGRAM" + +}; +.SH Constants +.IP "NVMF_RDMA_QPTYPE_CONNECTED" 12 +Reliable Connected +.IP "NVMF_RDMA_QPTYPE_DATAGRAM" 12 +Reliable Datagram diff --git a/doc/man/nvmf_register_ctrl.2 b/doc/man/nvmf_register_ctrl.2 new file mode 100644 index 0000000..813cac6 --- /dev/null +++ b/doc/man/nvmf_register_ctrl.2 @@ -0,0 +1,22 @@ +.TH "nvmf_register_ctrl" 9 "nvmf_register_ctrl" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvmf_register_ctrl \- Perform registration task with a DC +.SH SYNOPSIS +.B "int" nvmf_register_ctrl +.BI "(nvme_ctrl_t c " "," +.BI "enum nvmf_dim_tas tas " "," +.BI "__u32 *result " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller instance +.IP "tas" 12 +Task field of the Command Dword 10 (cdw10). Indicates whether to +perform a Registration, Deregistration, or Registration-update. +.IP "result" 12 +The command-specific result returned by the DC upon command +completion. +.SH "DESCRIPTION" +Perform registration task with a Discovery Controller (DC). Three +tasks are supported: register, deregister, and registration update. +.SH "RETURN" +0 on success; on failure -1 is returned and errno is set diff --git a/doc/man/nvmf_sectype_str.2 b/doc/man/nvmf_sectype_str.2 new file mode 100644 index 0000000..8dc8515 --- /dev/null +++ b/doc/man/nvmf_sectype_str.2 @@ -0,0 +1,14 @@ +.TH "nvmf_sectype_str" 9 "nvmf_sectype_str" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvmf_sectype_str \- Decode SECTYPE field +.SH SYNOPSIS +.B "const char *" nvmf_sectype_str +.BI "(__u8 sectype " ");" +.SH ARGUMENTS +.IP "sectype" 12 +value to be decoded +.SH "DESCRIPTION" +Decode the SECTYPE field in the discovery log page +entry. +.SH "RETURN" +decoded string diff --git a/doc/man/nvmf_subtype_str.2 b/doc/man/nvmf_subtype_str.2 new file mode 100644 index 0000000..1134736 --- /dev/null +++ b/doc/man/nvmf_subtype_str.2 @@ -0,0 +1,14 @@ +.TH "nvmf_subtype_str" 9 "nvmf_subtype_str" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvmf_subtype_str \- Decode SUBTYPE field +.SH SYNOPSIS +.B "const char *" nvmf_subtype_str +.BI "(__u8 subtype " ");" +.SH ARGUMENTS +.IP "subtype" 12 +value to be decoded +.SH "DESCRIPTION" +Decode the subsystem type field in the discovery +log page entry. +.SH "RETURN" +decoded string diff --git a/doc/man/nvmf_tcp_sectype.2 b/doc/man/nvmf_tcp_sectype.2 new file mode 100644 index 0000000..770e684 --- /dev/null +++ b/doc/man/nvmf_tcp_sectype.2 @@ -0,0 +1,26 @@ +.TH "libnvme" 9 "enum nvmf_tcp_sectype" "April 2022" "API Manual" LINUX +.SH NAME +enum nvmf_tcp_sectype \- Transport Specific Address Subtype Definition for NVMe/TCP Transport +.SH SYNOPSIS +enum nvmf_tcp_sectype { +.br +.BI " NVMF_TCP_SECTYPE_NONE" +, +.br +.br +.BI " NVMF_TCP_SECTYPE_TLS" +, +.br +.br +.BI " NVMF_TCP_SECTYPE_TLS13" + +}; +.SH Constants +.IP "NVMF_TCP_SECTYPE_NONE" 12 +No Security +.IP "NVMF_TCP_SECTYPE_TLS" 12 +Transport Layer Security version 1.2 +.IP "NVMF_TCP_SECTYPE_TLS13" 12 +Transport Layer Security version 1.3 or a subsequent +version. The TLS protocol negotiates the version and +cipher suite for each TCP connection. diff --git a/doc/man/nvmf_treq.2 b/doc/man/nvmf_treq.2 new file mode 100644 index 0000000..a1c01a1 --- /dev/null +++ b/doc/man/nvmf_treq.2 @@ -0,0 +1,30 @@ +.TH "libnvme" 9 "enum nvmf_treq" "April 2022" "API Manual" LINUX +.SH NAME +enum nvmf_treq \- Transport Requirements codes for Discovery Log Page entry TREQ field +.SH SYNOPSIS +enum nvmf_treq { +.br +.BI " NVMF_TREQ_NOT_SPECIFIED" +, +.br +.br +.BI " NVMF_TREQ_REQUIRED" +, +.br +.br +.BI " NVMF_TREQ_NOT_REQUIRED" +, +.br +.br +.BI " NVMF_TREQ_DISABLE_SQFLOW" + +}; +.SH Constants +.IP "NVMF_TREQ_NOT_SPECIFIED" 12 +Not specified +.IP "NVMF_TREQ_REQUIRED" 12 +Required +.IP "NVMF_TREQ_NOT_REQUIRED" 12 +Not Required +.IP "NVMF_TREQ_DISABLE_SQFLOW" 12 +SQ flow control disable supported diff --git a/doc/man/nvmf_treq_str.2 b/doc/man/nvmf_treq_str.2 new file mode 100644 index 0000000..3c5e7c3 --- /dev/null +++ b/doc/man/nvmf_treq_str.2 @@ -0,0 +1,14 @@ +.TH "nvmf_treq_str" 9 "nvmf_treq_str" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvmf_treq_str \- Decode TREQ field +.SH SYNOPSIS +.B "const char *" nvmf_treq_str +.BI "(__u8 treq " ");" +.SH ARGUMENTS +.IP "treq" 12 +value to be decoded +.SH "DESCRIPTION" +Decode the transport requirements field in the +discovery log page entry. +.SH "RETURN" +decoded string diff --git a/doc/man/nvmf_trtype.2 b/doc/man/nvmf_trtype.2 new file mode 100644 index 0000000..7d00ca7 --- /dev/null +++ b/doc/man/nvmf_trtype.2 @@ -0,0 +1,43 @@ +.TH "libnvme" 9 "enum nvmf_trtype" "April 2022" "API Manual" LINUX +.SH NAME +enum nvmf_trtype \- Transport Type codes for Discovery Log Page entry TRTYPE field +.SH SYNOPSIS +enum nvmf_trtype { +.br +.BI " NVMF_TRTYPE_UNSPECIFIED" +, +.br +.br +.BI " NVMF_TRTYPE_RDMA" +, +.br +.br +.BI " NVMF_TRTYPE_FC" +, +.br +.br +.BI " NVMF_TRTYPE_TCP" +, +.br +.br +.BI " NVMF_TRTYPE_LOOP" +, +.br +.br +.BI " NVMF_TRTYPE_MAX" + +}; +.SH Constants +.IP "NVMF_TRTYPE_UNSPECIFIED" 12 +Not indicated +.IP "NVMF_TRTYPE_RDMA" 12 +RDMA +.IP "NVMF_TRTYPE_FC" 12 +Fibre Channel +.IP "NVMF_TRTYPE_TCP" 12 +TCP +.IP "NVMF_TRTYPE_LOOP" 12 +Intra-host Transport (i.e., loopback), reserved +for host usage. +.IP "NVMF_TRTYPE_MAX" 12 +Maximum value for \fIenum nvmf_trtype\fP diff --git a/doc/man/nvmf_trtype_str.2 b/doc/man/nvmf_trtype_str.2 new file mode 100644 index 0000000..b46fe99 --- /dev/null +++ b/doc/man/nvmf_trtype_str.2 @@ -0,0 +1,14 @@ +.TH "nvmf_trtype_str" 9 "nvmf_trtype_str" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvmf_trtype_str \- Decode TRTYPE field +.SH SYNOPSIS +.B "const char *" nvmf_trtype_str +.BI "(__u8 trtype " ");" +.SH ARGUMENTS +.IP "trtype" 12 +value to be decoded +.SH "DESCRIPTION" +Decode the transport type field in the discovery +log page entry. +.SH "RETURN" +decoded string diff --git a/doc/man/nvmf_update_config.2 b/doc/man/nvmf_update_config.2 new file mode 100644 index 0000000..c23097b --- /dev/null +++ b/doc/man/nvmf_update_config.2 @@ -0,0 +1,15 @@ +.TH "nvmf_update_config" 9 "nvmf_update_config" "April 2022" "libnvme API manual" LINUX +.SH NAME +nvmf_update_config \- Update fabrics configuration values +.SH SYNOPSIS +.B "void" nvmf_update_config +.BI "(nvme_ctrl_t c " "," +.BI "const struct nvme_fabrics_config *cfg " ");" +.SH ARGUMENTS +.IP "c" 12 +Controller to be modified +.IP "cfg" 12 +Updated configuration values +.SH "DESCRIPTION" +Updates the values from \fIc\fP with the configuration values from \fIcfg\fP; +all non-default values from \fIcfg\fP will overwrite the values in \fIc\fP. diff --git a/doc/meson.build b/doc/meson.build new file mode 100644 index 0000000..0f04343 --- /dev/null +++ b/doc/meson.build @@ -0,0 +1,121 @@ +# SPDX-License-Identifier: LGPL-2.1-or-later +# +# This file is part of libnvme. +# Copyright (c) 2022 Dell Inc. +# Copyright (c) 2022 SUSE LLC +# +# Authors: Martin Belanger <Martin.Belanger@dell.com> +# Authors: Daniel Wagner <dwagner@suse.de> +# + +api_files = [ + 'filters.h', + 'ioctl.h', + 'linux.h', + 'log.h', + 'tree.h', + 'types.h', + 'fabrics.h', + 'util.h' +] + +sphinx_sources = [ + 'conf.py', + 'index.rst', + 'config-schema.json' +] + +want_docs = get_option('docs') +want_docs_build = get_option('docs-build') +if want_docs != 'false' + kernel_doc = find_program('kernel-doc') + + conf = configuration_data() + conf.set('SYSCONFDIR', sysconfdir) + + if want_docs == 'all' or want_docs == 'man' + mandir = join_paths(get_option('mandir'), 'man2') + list_man_pages = find_program('list-man-pages.sh') + if want_docs_build + foreach apif : api_files + foreach file : files('../src/nvme/' + apif) + subst = configure_file( + input: file, + output: '@BASENAME@.msubst', + configuration: conf) + c = run_command(list_man_pages, subst) + man_pages = c.stdout().split() + foreach page : man_pages + custom_target( + page.underscorify() + '_man', + input: subst, + output: page + '.2', + capture: true, + command: [kernel_doc, + '-module', 'libnvme', + '-man', + '-function', + page, + subst], + install: true, + install_dir: mandir) + endforeach + endforeach + endforeach + else + if want_docs == 'all' or want_docs == 'man' + install_subdir('man', install_dir: mandir) + endif + endif + endif + + if want_docs == 'all' or want_docs == 'html' + htmldir = join_paths(get_option('htmldir'), 'nvme') + sphinx_build = find_program('sphinx-build-3', 'sphinx-build') + if sphinx_build.found() and want_docs_build + cat = find_program('cat') + rsts = [] + foreach apif : api_files + afile = files('../src/nvme/' + apif) + subst = configure_file( + input: afile, + output: '@BASENAME@.hsubst', + configuration: conf) + rst = custom_target( + apif.underscorify() + '_rst', + input: subst, + output: '@BASENAME@._rst', + capture: true, + command: [kernel_doc, + '-rst', + '@INPUT@']) + rsts += rst + endforeach + libnvme = custom_target( + 'libnvme', + command: [ cat, '@INPUT@' ], + capture: true, + input: rsts, + output: 'libnvme.rst') + static_sources = [] + foreach file : sphinx_sources + static_sources += configure_file(input: file, output: file, copy: true) + endforeach + custom_target( + 'generate_doc_html', + input: [static_sources, libnvme], + output: 'html', + command: [sphinx_build, + '-b', 'html', + '@OUTDIR@', + '@OUTDIR@' + '/html'], + install: true, + install_dir: htmldir) + else + # The HTML doc is not ready yet. + # if want_docs == 'all' or want_docs == 'html' + # install_subdir('html', install_dir: htmldir) + # endif + endif + endif +endif diff --git a/doc/update-docs.sh b/doc/update-docs.sh new file mode 100755 index 0000000..7765b9b --- /dev/null +++ b/doc/update-docs.sh @@ -0,0 +1,19 @@ +#!/bin/sh -x + +DESTDIR=$(pwd) + +BUILDDIR="$(mktemp -d)" +trap 'rm -rf -- $BUILDDIR' EXIT + +meson $BUILDDIR -Ddocs=man -Ddocs-build=true +ninja -C $BUILDDIR + +rm -rf $DESTDIR/doc/man +mkdir $DESTDIR/doc/man + +find $BUILDDIR/doc -maxdepth 1 -name '*.2' -exec cp {} $DESTDIR/doc/man \; + +# The HTML doc is not ready yet +# rm -rf $DESTDIR/doc/html +# cp -R $BUILDDIR/doc/html $DESTDIR/doc/ + diff --git a/examples/discover-loop.c b/examples/discover-loop.c new file mode 100644 index 0000000..a577cd4 --- /dev/null +++ b/examples/discover-loop.c @@ -0,0 +1,89 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/** + * This file is part of libnvme. + * Copyright (c) 2020 Western Digital Corporation or its affiliates. + * + * Authors: Keith Busch <keith.busch@wdc.com> + */ + +/** + * discover-loop: Use fabrics commands to discover any loop targets and print + * those records. You must have at least one configured nvme loop target on the + * system (no existing connection required). The output will look more + * interesting with more targets. + */ +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <errno.h> +#include <libnvme.h> + +#include <ccan/endian/endian.h> + +static void print_discover_log(struct nvmf_discovery_log *log) +{ + int i, numrec = le64_to_cpu(log->numrec); + + printf(".\n"); + printf("|-- genctr:%llx\n", log->genctr); + printf("|-- numrec:%x\n", numrec); + printf("`-- recfmt:%x\n", log->recfmt); + + for (i = 0; i < numrec; i++) { + struct nvmf_disc_log_entry *e = &log->entries[i]; + + printf(" %c-- Entry:%d\n", (i < numrec - 1) ? '|' : '`', i); + printf(" %c |-- trtype:%x\n", (i < numrec - 1) ? '|' : ' ', e->trtype); + printf(" %c |-- adrfam:%x\n", (i < numrec - 1) ? '|' : ' ', e->adrfam); + printf(" %c |-- subtype:%x\n", (i < numrec - 1) ? '|' : ' ', e->subtype); + printf(" %c |-- treq:%x\n", (i < numrec - 1) ? '|' : ' ', e->treq); + printf(" %c |-- portid:%x\n", (i < numrec - 1) ? '|' : ' ', e->portid); + printf(" %c |-- cntlid:%x\n", (i < numrec - 1) ? '|' : ' ', e->cntlid); + printf(" %c |-- asqsz:%x\n", (i < numrec - 1) ? '|' : ' ', e->asqsz); + printf(" %c |-- trsvcid:%s\n", (i < numrec - 1) ? '|' : ' ', e->trsvcid); + printf(" %c |-- subnqn:%s\n", (i < numrec - 1) ? '|' : ' ', e->subnqn); + printf(" %c `-- traddr:%s\n", (i < numrec - 1) ? '|' : ' ', e->traddr); + } +} + +int main() +{ + struct nvmf_discovery_log *log = NULL; + nvme_root_t r; + nvme_host_t h; + nvme_ctrl_t c; + int ret; + struct nvme_fabrics_config cfg; + + nvmf_default_config(&cfg); + + r = nvme_scan(NULL); + h = nvme_default_host(r); + if (!h) { + fprintf(stderr, "Failed to allocated memory\n"); + return ENOMEM; + } + c = nvme_create_ctrl(r, NVME_DISC_SUBSYS_NAME, "loop", + NULL, NULL, NULL, NULL); + if (!c) { + fprintf(stderr, "Failed to allocate memory\n"); + return ENOMEM; + } + ret = nvmf_add_ctrl(h, c, &cfg); + if (ret < 0) { + fprintf(stderr, "no controller found\n"); + return errno; + } + + ret = nvmf_get_discovery_log(c, &log, 4); + nvme_disconnect_ctrl(c); + nvme_free_ctrl(c); + + if (ret) + fprintf(stderr, "nvmf-discover-log:%x\n", ret); + else + print_discover_log(log); + + nvme_free_tree(r); + return 0; +} diff --git a/examples/discover-loop.py b/examples/discover-loop.py new file mode 100644 index 0000000..94e8c72 --- /dev/null +++ b/examples/discover-loop.py @@ -0,0 +1,35 @@ +#!/usr/bin/python3 +''' +Example script for nvme discovery + +Copyright (c) 2021 Hannes Reinecke, SUSE Software Solutions +Licensed under the Apache License, Version 2.0 (the "License"); you may +not use this file except in compliance with the License. You may obtain +a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +License for the specific language governing permissions and limitations +under the License. +''' + +from libnvme import nvme +r = nvme.root() +h = nvme.host(r) +c = nvme.ctrl(nvme.NVME_DISC_SUBSYS_NAME, 'loop') +try: + c.connect(h) +except: + sys.exit("Failed to connect!") + +print("connected to %s subsys %s" % (c.name, c.subsystem.name)) +try: + d = c.discover() + print (d) +except: + print("Failed to discover!") + pass +c.disconnect() diff --git a/examples/display-columnar.c b/examples/display-columnar.c new file mode 100644 index 0000000..db98bdf --- /dev/null +++ b/examples/display-columnar.c @@ -0,0 +1,121 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/** + * This file is part of libnvme. + * Copyright (c) 2020 Western Digital Corporation or its affiliates. + * + * Authors: Keith Busch <keith.busch@wdc.com> + */ + +/** + * display-columnar: Scans the nvme topology, prints each record type in a + * column format for easy visual scanning. + */ +#include <stdio.h> +#include <inttypes.h> +#include <libnvme.h> + +static const char dash[101] = {[0 ... 99] = '-'}; +int main() +{ + nvme_root_t r; + nvme_host_t h; + nvme_subsystem_t s; + nvme_ctrl_t c; + nvme_path_t p; + nvme_ns_t n; + + r = nvme_scan(NULL); + if (!r) + return -1; + + + printf("%-16s %-96s %-.16s\n", "Subsystem", "Subsystem-NQN", "Controllers"); + printf("%-.16s %-.96s %-.16s\n", dash, dash, dash); + + nvme_for_each_host(r, h) { + nvme_for_each_subsystem(h, s) { + bool first = true; + printf("%-16s %-96s ", nvme_subsystem_get_name(s), + nvme_subsystem_get_nqn(s)); + + nvme_subsystem_for_each_ctrl(s, c) { + printf("%s%s", first ? "": ", ", + nvme_ctrl_get_name(c)); + first = false; + } + printf("\n"); + } + } + printf("\n"); + + printf("%-8s %-20s %-40s %-8s %-6s %-14s %-12s %-16s\n", "Device", + "SN", "MN", "FR", "TxPort", "Address", "Subsystem", "Namespaces"); + printf("%-.8s %-.20s %-.40s %-.8s %-.6s %-.14s %-.12s %-.16s\n", dash, dash, + dash, dash, dash, dash, dash, dash); + + nvme_for_each_host(r, h) { + nvme_for_each_subsystem(h, s) { + nvme_subsystem_for_each_ctrl(s, c) { + bool first = true; + + printf("%-8s %-20s %-40s %-8s %-6s %-14s %-12s ", + nvme_ctrl_get_name(c), + nvme_ctrl_get_serial(c), + nvme_ctrl_get_model(c), + nvme_ctrl_get_firmware(c), + nvme_ctrl_get_transport(c), + nvme_ctrl_get_address(c), + nvme_subsystem_get_name(s)); + + nvme_ctrl_for_each_ns(c, n) { + printf("%s%s", first ? "": ", ", + nvme_ns_get_name(n)); + first = false; + } + + nvme_ctrl_for_each_path(c, p) { + printf("%s%s", first ? "": ", ", + nvme_ns_get_name(nvme_path_get_ns(p))); + first = false; + } + printf("\n"); + } + } + } + printf("\n"); + + printf("%-12s %-8s %-16s %-8s %-16s\n", "Device", "NSID", "Sectors", "Format", "Controllers"); + printf("%-.12s %-.8s %-.16s %-.8s %-.16s\n", dash, dash, dash, dash, dash); + + nvme_for_each_host(r, h) { + nvme_for_each_subsystem(h, s) { + nvme_subsystem_for_each_ctrl(s, c) { + nvme_ctrl_for_each_ns(c, n) + printf("%-12s %-8d %-16" PRIu64 " %-8d %s\n", + nvme_ns_get_name(n), + nvme_ns_get_nsid(n), + nvme_ns_get_lba_count(n), + nvme_ns_get_lba_size(n), + nvme_ctrl_get_name(c)); + } + + nvme_subsystem_for_each_ns(s, n) { + bool first = true; + + printf("%-12s %-8d %-16" PRIu64 " %-8d ", + nvme_ns_get_name(n), + nvme_ns_get_nsid(n), + nvme_ns_get_lba_count(n), + nvme_ns_get_lba_size(n)); + nvme_subsystem_for_each_ctrl(s, c) { + printf("%s%s", first ? "" : ", ", + nvme_ctrl_get_name(c)); + first = false; + } + printf("\n"); + } + } + } + return 0; +} + diff --git a/examples/display-tree.c b/examples/display-tree.c new file mode 100644 index 0000000..f5bddb2 --- /dev/null +++ b/examples/display-tree.c @@ -0,0 +1,71 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/** + * This file is part of libnvme. + * Copyright (c) 2020 Western Digital Corporation or its affiliates. + * + * Authors: Keith Busch <keith.busch@wdc.com> + */ + +/** + * display-tree: Scans the nvme topology, prints as an ascii tree with some + * selected attributes for each component. + */ +#include <stdio.h> +#include <libnvme.h> + +int main() +{ + nvme_root_t r; + nvme_host_t h; + nvme_subsystem_t s, _s; + nvme_ctrl_t c, _c; + nvme_path_t p, _p; + nvme_ns_t n, _n; + + r = nvme_scan(NULL); + if (!r) + return -1; + + printf(".\n"); + nvme_for_each_host(r, h) { + nvme_for_each_subsystem_safe(h, s, _s) { + printf("%c-- %s - NQN=%s\n", _s ? '|' : '`', + nvme_subsystem_get_name(s), + nvme_subsystem_get_nqn(s)); + + nvme_subsystem_for_each_ns_safe(s, n, _n) { + printf("%c |-- %s lba size:%d lba max:%lu\n", + _s ? '|' : ' ', + nvme_ns_get_name(n), + nvme_ns_get_lba_size(n), + nvme_ns_get_lba_count(n)); + } + + nvme_subsystem_for_each_ctrl_safe(s, c, _c) { + printf("%c %c-- %s %s %s %s\n", + _s ? '|' : ' ', _c ? '|' : '`', + nvme_ctrl_get_name(c), + nvme_ctrl_get_transport(c), + nvme_ctrl_get_address(c), + nvme_ctrl_get_state(c)); + + nvme_ctrl_for_each_ns_safe(c, n, _n) + printf("%c %c %c-- %s lba size:%d lba max:%lu\n", + _s ? '|' : ' ', _c ? '|' : ' ', + _n ? '|' : '`', + nvme_ns_get_name(n), + nvme_ns_get_lba_size(n), + nvme_ns_get_lba_count(n)); + + nvme_ctrl_for_each_path_safe(c, p, _p) + printf("%c %c %c-- %s %s\n", + _s ? '|' : ' ', _c ? '|' : ' ', + _p ? '|' : '`', + nvme_path_get_name(p), + nvme_path_get_ana_state(p)); + } + } + } + nvme_free_tree(r); + return 0; +} diff --git a/examples/meson.build b/examples/meson.build new file mode 100644 index 0000000..f1f8ee5 --- /dev/null +++ b/examples/meson.build @@ -0,0 +1,34 @@ +# SPDX-License-Identifier: LGPL-2.1-or-later +# +# This file is part of libnvme. +# Copyright (c) 2021 Dell Inc. +# +# Authors: Martin Belanger <Martin.Belanger@dell.com> +# +executable( + 'telemetry-listen', + ['telemetry-listen.c'], + link_with: libnvme, + include_directories: [incdir, internal_incdir] +) + +executable( + 'display-columnar', + ['display-columnar.c'], + link_with: libnvme, + include_directories: [incdir, internal_incdir] +) + +executable( + 'display-tree', + ['display-tree.c'], + link_with: libnvme, + include_directories: [incdir, internal_incdir] +) + +executable( + 'discover-loop', + ['discover-loop.c'], + link_with: libnvme, + include_directories: [incdir, internal_incdir] +) diff --git a/examples/telemetry-listen.c b/examples/telemetry-listen.c new file mode 100644 index 0000000..746992b --- /dev/null +++ b/examples/telemetry-listen.c @@ -0,0 +1,167 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/** + * This file is part of libnvme. + * Copyright (c) 2020 Western Digital Corporation or its affiliates. + * + * Authors: Keith Busch <keith.busch@wdc.com> + */ + +/** + * Open all nvme controller's uevent and listen for changes. If NVME_AEN event + * is observed with controller telemetry data, read the log and save it to a + * file in /var/log/ with the device's unique name and epoch timestamp. + */ +#include <fcntl.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <time.h> +#include <libnvme.h> + +#include <ccan/endian/endian.h> + +struct events { + nvme_ctrl_t c; + int uevent_fd; +}; + +static int open_uevent(nvme_ctrl_t c) +{ + char buf[0x1000]; + if (snprintf(buf, sizeof(buf), "%s/uevent", nvme_ctrl_get_sysfs_dir(c)) < 0) + return -1; + return open(buf, O_RDONLY); +} + +static void save_telemetry(nvme_ctrl_t c) +{ + char buf[0x1000]; + size_t log_size; + int ret, fd; + struct nvme_telemetry_log *log; + time_t s; + + /* Clear the log (rae == false) at the end to see new telemetry events later */ + ret = nvme_get_ctrl_telemetry(nvme_ctrl_get_fd(c), false, &log, NVME_TELEMETRY_DA_3, &log_size); + if (ret) + return; + + s = time(NULL); + ret = snprintf(buf, sizeof(buf), "/var/log/%s-telemetry-%ld", + nvme_ctrl_get_subsysnqn(c), s); + if (ret < 0) { + free(log); + return; + } + log_size = (le16_to_cpu(log->dalb3) + 1) * NVME_LOG_TELEM_BLOCK_SIZE; + + fd = open(buf, O_CREAT|O_WRONLY, S_IRUSR|S_IRGRP); + if (fd < 0) { + free(log); + return; + } + + ret = write(fd, log, log_size); + if (ret < 0) + printf("failed to write telemetry log\n"); + else + printf("telemetry log save as %s, wrote:%d size:%ld\n", buf, + ret, log_size); + close(fd); + free(log); +} + +static void check_telemetry(nvme_ctrl_t c, int ufd) +{ + char buf[0x1000] = { 0 }; + char *p, *ptr; + + if (read(ufd, buf, sizeof(buf)) < 0) + return; + + ptr = buf; + while ((p = strsep(&ptr, "\n")) != NULL) { + __u32 aen, type, info, lid; + + if (sscanf(p, "NVME_AEN=0x%08x", &aen) != 1) + continue; + + type = aen & 0x07; + info = (aen >> 8) & 0xff; + lid = (aen >> 16) & 0xff; + + printf("%s: aen type:%x info:%x lid:%d\n", + nvme_ctrl_get_name(c), type, info, lid); + if (type == NVME_AER_NOTICE && + info == NVME_AER_NOTICE_TELEMETRY) + save_telemetry(c); + } +} + +static void wait_events(fd_set *fds, struct events *e, int nr) +{ + int ret, i; + + for (i = 0; i < nr; i++) + check_telemetry(e[i].c, e[i].uevent_fd); + + while (1) { + ret = select(nr, fds, NULL, NULL, NULL); + if (ret < 0) + return; + + for (i = 0; i < nr; i++) { + if (!FD_ISSET(e[i].uevent_fd, fds)) + continue; + check_telemetry(e[i].c, e[i].uevent_fd); + } + } +} + +int main() +{ + struct events *e; + fd_set fds; + int i = 0; + + nvme_subsystem_t s; + nvme_ctrl_t c; + nvme_host_t h; + nvme_root_t r; + + r = nvme_scan(NULL); + if (!r) + return EXIT_FAILURE; + + nvme_for_each_host(r, h) + nvme_for_each_subsystem(h, s) + nvme_subsystem_for_each_ctrl(s, c) + i++; + + e = calloc(i, sizeof(e)); + FD_ZERO(&fds); + i = 0; + + nvme_for_each_host(r, h) { + nvme_for_each_subsystem(h, s) { + nvme_subsystem_for_each_ctrl(s, c) { + int fd = open_uevent(c); + + if (fd < 0) + continue; + FD_SET(fd, &fds); + e[i].uevent_fd = fd; + e[i].c = c; + i++; + } + } + } + + wait_events(&fds, e, i); + nvme_free_tree(r); + free(e); + + return EXIT_SUCCESS; +} diff --git a/internal/meson.build b/internal/meson.build new file mode 100644 index 0000000..fde4cca --- /dev/null +++ b/internal/meson.build @@ -0,0 +1,21 @@ +# SPDX-License-Identifier: LGPL-2.1-or-later +# +# This file is part of libnvme. +# Copyright (c) 2022 Dell Inc. +# +# Authors: Martin Belanger <Martin.Belanger@dell.com> +# +# Because libnvme is used as a subproject of nvme-cli, +# the config.h file must be generated as a private file +# hidden from nvme-cli. + +config_h = configure_file( + output: 'config.h', + configuration: conf +) + +internal_incdir = include_directories('.') + +config_dep = declare_dependency( + include_directories : internal_incdir, + sources: config_h) diff --git a/libnvme.pc.in b/libnvme.pc.in new file mode 100644 index 0000000..a1867aa --- /dev/null +++ b/libnvme.pc.in @@ -0,0 +1,12 @@ +prefix=@prefix@ +exec_prefix=${prefix} +libdir=@libdir@ +includedir=@includedir@ + +Name: @NAME@ +Version: @VERSION@ +Description: Manage "libnvme" subsystem devices (Non-volatile Memory Express) +URL: http://github.com/linux-nvme/libnvme/ + +Libs: -L${libdir} -lnvme +Cflags: -I${includedir} diff --git a/libnvme.spec.in b/libnvme.spec.in new file mode 100644 index 0000000..8a2e4e5 --- /dev/null +++ b/libnvme.spec.in @@ -0,0 +1,57 @@ +Name: @NAME@ +Version: @VERSION@ +Release: 0 +Summary: Linux-native nvme device management library + +License: @LICENSE@ +Source: %{name}-%{version}.tar.gz +BuildRoot: %{_tmppath}/%{name}-root +URL: http://github.com/linux-nvme/libnvme + +BuildRequires: libuuid-devel +BuildRequires: meson +BuildRequires: gcc + +%description +Provides library functions for accessing and managing nvme devices on a Linux +system. + +%package devel +Summary: Development files for Linux-native nvme +Requires: libnvme +Provides: libnvme.so.1 + +%description devel +This package provides header files to include and libraries to link with +for Linux-native nvme device maangement. + +%prep +%autosetup -c + +%build +%meson +%meson_build + +%install +%meson_install + +%check +%meson_test + +%files +%defattr(-,root,root) +%attr(0755,root,root) %{_libdir}/libnvme.so.* +%doc COPYING + +%files devel +%defattr(-,root,root) +%attr(-,root,root) %{_includedir}/nvme/ +%attr(0644,root,root) %{_includedir}/libnvme.h +%attr(0755,root,root) %{_libdir}/libnvme.so +%attr(0644,root,root) %{_libdir}/libnvme.a +%attr(0644,root,root) %{_libdir}/pkgconfig/* +%attr(0644,root,root) %{_mandir}/man2/* + +%changelog +* Thu Dec 12 2019 Keith Busch <kbusch@kernel.org> - 0.1 +- Initial version diff --git a/libnvme/.gitignore b/libnvme/.gitignore new file mode 100644 index 0000000..e943f50 --- /dev/null +++ b/libnvme/.gitignore @@ -0,0 +1,4 @@ +build/ +__pycache__/ +nvme.py +nvme_wrap.c diff --git a/libnvme/README.md b/libnvme/README.md new file mode 100644 index 0000000..f61e5cc --- /dev/null +++ b/libnvme/README.md @@ -0,0 +1,46 @@ +# Python bindings for libnvme + +We use [SWIG](http://www.swig.org/) to generate Python bindings for libnvme. + +## How to use + +```python +#!/usr/bin/env python3 +import sys +import pprint +from libnvme import nvme + +root = nvme.root() # This is a singleton +root.log_level('debug') # Optional: extra debug info + +host = nvme.host(root) # This "may be" a singleton. +sybsysnqn = [string] # e.g. 'nqn.2014-08.org.nvmexpress.discovery', nvme.NVME_DISC_SUBSYS_NAME, ... +transport = [string] # One of: 'tcp, 'rdma', 'fc', 'loop'. +traddr = [IPv4 or IPv6] # e.g. '192.168.10.10', 'fd2e:853b:3cad:e135:506a:65ee:29f2:1b18', ... +trsvcid = [string] # e.g. '8009', '4420', ... +host_iface = [interface] # e.g. 'eth1', ens256', ... +ctrl = nvme.ctrl(subsysnqn=subsysnqn, transport=transport, traddr=traddr, trsvcid=trsvcid, host_iface=host_iface) + +try: + cfg = { + 'hdr_digest': True, # Enable header digests + 'data_digest': False, # Disable data digests + } + ctrl.connect(host, cfg) + print(f"connected to {ctrl.name} subsys {ctrl.subsystem.name}") +except Exception as e: + sys.exit(f'Failed to connect: {e}') + +try: + log_pages = ctrl.discover() + print(pprint.pformat(log_pages)) +except Exception as e: + sys.exit(f'Failed to retrieve log pages: {e}') + +try: + ctrl.disconnect() +except Exception as e: + sys.exit(f'Failed to disconnect: {e}') + +``` + diff --git a/libnvme/__init__.py b/libnvme/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/libnvme/__init__.py diff --git a/libnvme/meson.build b/libnvme/meson.build new file mode 100644 index 0000000..c95444e --- /dev/null +++ b/libnvme/meson.build @@ -0,0 +1,71 @@ +# SPDX-License-Identifier: LGPL-2.1-or-later +# +# This file is part of libnvme. +# Copyright (c) 2021 Dell Inc. +# +# Authors: Martin Belanger <Martin.Belanger@dell.com> +# +want_python = get_option('python') +if want_python != 'false' + python3 = import('python').find_installation('python3') + py3_dep = python3.dependency(required: want_python == 'true') + swig = find_program('swig', required: want_python == 'true') + header_found = cc.has_header('Python.h', dependencies: py3_dep) + have_python_support = py3_dep.found() and swig.found() and header_found +else + have_python_support = false +endif + +if have_python_support + pymod_swig = custom_target( + 'nvme.py', + input: ['nvme.i'], + output: ['nvme.py', 'nvme_wrap.c'], + command: [swig, '-python', '-py3', '-o', '@OUTPUT1@', '@INPUT0@'], + install: true, + install_dir: [python3.get_install_dir(pure: false, subdir: 'libnvme'), false], + ) + + pynvme_clib = python3.extension_module( + '_nvme', + pymod_swig[1], + dependencies : py3_dep, + include_directories: [incdir, internal_incdir], + link_with: [libnvme, libccan], + install: true, + subdir: 'libnvme', + ) + + # Little hack to copy file __init__.py to the build directory. + # This is needed to create the proper directory layout to run the tests. + # It's a hack because we don't really "configure" file __init__.py and we + # could simply install directly from the source tree with: + # python3.install_sources(['__init__.py', ], pure:false, subdir:'libnvme') + # However, since we need __init__.py in the build directory to run the tests + # we resort to this hack to copy it. + configure_file( + input: '__init__.py', + output: '__init__.py', + copy: true, + install_dir: python3.get_install_dir(pure: false, subdir: 'libnvme'), + ) + + # Set the PYTHONPATH so that we can run the + # tests directly from the build directory. + test_env = environment() + test_env.append('MALLOC_PERTURB_', '0') + test_env.append('PYTHONPATH', join_paths(meson.current_build_dir(), '..')) + test_env.append('PYTHONMALLOC', 'malloc') + + # Test section + test('[Python] import libnvme', python3, args: ['-c', 'from libnvme import nvme'], env: test_env, depends: pynvme_clib) + + py_tests = [ + [ 'create ctrl object', files('tests/create-ctrl-obj.py') ], + ] + foreach test: py_tests + description = test[0] + py_script = test[1] + test('[Python] ' + description, python3, args: [py_script, ], env: test_env, depends: pynvme_clib) + endforeach +endif diff --git a/libnvme/nvme.i b/libnvme/nvme.i new file mode 100644 index 0000000..ec680be --- /dev/null +++ b/libnvme/nvme.i @@ -0,0 +1,690 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/* + * This file is part of libnvme. + * Copyright (c) 2021 SUSE Software Solutions + * + * Authors: Hannes Reinecke <hare@suse.de> + */ + +%module(docstring="Python bindings for libnvme") nvme +%feature("autodoc", "1"); + +%include "exception.i" + +%allowexception; + +%rename(root) nvme_root; +%rename(host) nvme_host; +%rename(ctrl) nvme_ctrl; +%rename(subsystem) nvme_subsystem; +%rename(ns) nvme_ns; + +%{ +#include <ccan/list/list.h> +#include "nvme/tree.h" +#include "nvme/fabrics.h" +#include "nvme/private.h" +#include "nvme/log.h" + +static int host_iter_err = 0; +static int subsys_iter_err = 0; +static int ctrl_iter_err = 0; +static int ns_iter_err = 0; +static int connect_err = 0; +static int discover_err = 0; +%} + +%inline %{ + struct host_iter { + struct nvme_root *root; + struct nvme_host *pos; + }; + + struct subsystem_iter { + struct nvme_host *host; + struct nvme_subsystem *pos; + }; + + struct ctrl_iter { + struct nvme_subsystem *subsystem; + struct nvme_ctrl *pos; + }; + + struct ns_iter { + struct nvme_subsystem *subsystem; + struct nvme_ctrl *ctrl; + struct nvme_ns *pos; + }; +%} + +%exception host_iter::__next__ { + host_iter_err = 0; + $action /* $action sets host_iter_err to non-zero value on failure */ + if (host_iter_err) { + PyErr_SetString(PyExc_StopIteration, "End of list"); + return NULL; + } +} + +%exception subsystem_iter::__next__ { + subsys_iter_err = 0; + $action /* $action sets subsys_iter_err to non-zero value on failure */ + if (subsys_iter_err) { + PyErr_SetString(PyExc_StopIteration, "End of list"); + return NULL; + } +} + +%exception ctrl_iter::__next__ { + ctrl_iter_err = 0; + $action /* $action sets ctrl_iter_err to non-zero value on failure */ + if (ctrl_iter_err) { + PyErr_SetString(PyExc_StopIteration, "End of list"); + return NULL; + } +} + +%exception ns_iter::__next__ { + ns_iter_err = 0; + $action /* $action sets ns_iter_err to non-zero value on failure */ + if (ns_iter_err) { + PyErr_SetString(PyExc_StopIteration, "End of list"); + return NULL; + } +} + +%exception nvme_ctrl::connect { + connect_err = 0; + errno = 0; + $action /* $action sets connect_err to non-zero value on failure */ + if (connect_err == 1) { + SWIG_exception(SWIG_AttributeError, "Existing controller connection"); + } else if (connect_err) { + const char *errstr = nvme_errno_to_string(errno); + if (errstr) { + SWIG_exception(SWIG_RuntimeError, errstr); + } else { + SWIG_exception(SWIG_RuntimeError, "Connect failed"); + } + } +} + +%exception nvme_ctrl::discover { + discover_err = 0; + $action /* $action sets discover_err to non-zero value on failure */ + if (discover_err) { + SWIG_exception(SWIG_RuntimeError,"Discover failed"); + } +} + +#include "tree.h" +#include "fabrics.h" + +%typemap(in) struct nvme_fabrics_config * ($*1_type temp) { + Py_ssize_t pos = 0; + PyObject *key, *value; + memset(&temp, 0, sizeof(temp)); + temp.tos = -1; + temp.ctrl_loss_tmo = NVMF_DEF_CTRL_LOSS_TMO; + while (PyDict_Next($input, &pos, &key, &value)) { + if (!PyUnicode_CompareWithASCIIString(key, "host_traddr")) + temp.host_traddr = PyBytes_AsString(value); + if (!PyUnicode_CompareWithASCIIString(key, "host_iface")) + temp.host_iface = PyBytes_AsString(value); + if (!PyUnicode_CompareWithASCIIString(key, "nr_io_queues")) + temp.nr_io_queues = PyLong_AsLong(value); + if (!PyUnicode_CompareWithASCIIString(key, "reconnect_delay")) + temp.reconnect_delay = PyLong_AsLong(value); + if (!PyUnicode_CompareWithASCIIString(key, "ctrl_loss_tmo")) + temp.ctrl_loss_tmo = PyLong_AsLong(value); + if (!PyUnicode_CompareWithASCIIString(key, "keep_alive_tmo")) + temp.keep_alive_tmo = PyLong_AsLong(value); + if (!PyUnicode_CompareWithASCIIString(key, "nr_write_queues")) + temp.nr_write_queues = PyLong_AsLong(value); + if (!PyUnicode_CompareWithASCIIString(key, "nr_poll_queues")) + temp.nr_poll_queues = PyLong_AsLong(value); + if (!PyUnicode_CompareWithASCIIString(key, "tos")) + temp.tos = PyLong_AsLong(value); + if (!PyUnicode_CompareWithASCIIString(key, "duplicate_connect")) + temp.duplicate_connect = PyObject_IsTrue(value) ? true : false; + if (!PyUnicode_CompareWithASCIIString(key, "disable_sqflow")) + temp.disable_sqflow = PyObject_IsTrue(value) ? true : false; + if (!PyUnicode_CompareWithASCIIString(key, "hdr_digest")) + temp.hdr_digest = PyObject_IsTrue(value) ? true : false; + if (!PyUnicode_CompareWithASCIIString(key, "data_digest")) + temp.data_digest = PyObject_IsTrue(value) ? true : false; + } + $1 = &temp; + }; + +%typemap(out) uint8_t [8] { + $result = PyBytes_FromStringAndSize((char *)$1, 8); +}; + +%typemap(out) uint8_t [16] { + $result = PyBytes_FromStringAndSize((char *)$1, 16); +}; + +%typemap(newfree) struct nvmf_discovery_log * { + if ($1) free($1); +} + +%{ +static void PyDict_SetItemStringDecRef(PyObject *p, const char *key, PyObject *val) { + PyDict_SetItemString(p, key, val); /* Does NOT steal reference to val .. */ + Py_XDECREF(val); /* .. therefore decrement ref. count. */ +} +%} + +%typemap(out) struct nvmf_discovery_log * { + struct nvmf_discovery_log *log = $1; + int numrec = log? log->numrec : 0, i; + PyObject *obj = PyList_New(numrec); + if (!obj) + return NULL; + for (i = 0; i < numrec; i++) { + struct nvmf_disc_log_entry *e = &log->entries[i]; + PyObject *entry = PyDict_New(), *val; + + switch (e->trtype) { + case NVMF_TRTYPE_UNSPECIFIED: + val = PyUnicode_FromString("unspecified"); + break; + case NVMF_TRTYPE_RDMA: + val = PyUnicode_FromString("rdma"); + break; + case NVMF_TRTYPE_FC: + val = PyUnicode_FromString("fc"); + break; + case NVMF_TRTYPE_TCP: + val = PyUnicode_FromString("tcp"); + break; + case NVMF_TRTYPE_LOOP: + val = PyUnicode_FromString("loop"); + break; + default: + val = PyLong_FromLong(e->trtype); + } + PyDict_SetItemStringDecRef(entry, "trtype", val); + switch (e->adrfam) { + case NVMF_ADDR_FAMILY_PCI: + val = PyUnicode_FromString("pci"); + break; + case NVMF_ADDR_FAMILY_IP4: + val = PyUnicode_FromString("ipv4"); + break; + case NVMF_ADDR_FAMILY_IP6: + val = PyUnicode_FromString("ipv6"); + break; + case NVMF_ADDR_FAMILY_IB: + val = PyUnicode_FromString("infiniband"); + break; + case NVMF_ADDR_FAMILY_FC: + val = PyUnicode_FromString("fc"); + break; + default: + val = PyLong_FromLong(e->adrfam); + } + PyDict_SetItemStringDecRef(entry, "adrfam", val); + val = PyUnicode_FromString(e->traddr); + PyDict_SetItemStringDecRef(entry, "traddr", val); + val = PyUnicode_FromString(e->trsvcid); + PyDict_SetItemStringDecRef(entry, "trsvcid", val); + val = PyUnicode_FromString(e->subnqn); + PyDict_SetItemStringDecRef(entry, "subnqn", val); + switch (e->subtype) { + case NVME_NQN_DISC: + val = PyUnicode_FromString("referral"); + break; + case NVME_NQN_NVME: + val = PyUnicode_FromString("nvme"); + break; + case NVME_NQN_CURR: + val = PyUnicode_FromString("discovery"); + break; + default: + val = PyLong_FromLong(e->subtype); + } + PyDict_SetItemStringDecRef(entry, "subtype", val); + switch (e->treq) { + case NVMF_TREQ_NOT_SPECIFIED: + val = PyUnicode_FromString("not specified"); + break; + case NVMF_TREQ_REQUIRED: + val = PyUnicode_FromString("required"); + break; + case NVMF_TREQ_NOT_REQUIRED: + val = PyUnicode_FromString("not required"); + break; + case NVMF_TREQ_DISABLE_SQFLOW: + val = PyUnicode_FromString("disable sqflow"); + break; + default: + val = PyLong_FromLong(e->treq); + } + PyDict_SetItemStringDecRef(entry, "treq", val); + val = PyLong_FromLong(e->portid); + PyDict_SetItemStringDecRef(entry, "portid", val); + val = PyLong_FromLong(e->cntlid); + PyDict_SetItemStringDecRef(entry, "cntlid", val); + val = PyLong_FromLong(e->asqsz); + PyDict_SetItemStringDecRef(entry, "asqsz", val); + PyList_SetItem(obj, i, entry); /* steals ref. to entry */ + } + $result = obj; + }; +struct nvme_root { + %immutable config_file; + char *config_file; +}; + +struct nvme_host { + %immutable hostnqn; + %immutable hostid; + %immutable hostsymname; + char *hostnqn; + char *hostid; + char *hostsymname; + char *dhchap_key; +}; + +struct nvme_subsystem { + %immutable subsysnqn; + %immutable model; + %immutable serial; + %immutable firmware; + char *subsysnqn; + char *model; + char *serial; + char *firmware; +}; + +struct nvme_ctrl { + %immutable transport; + %immutable subsysnqn; + %immutable traddr; + %immutable trsvcid; + %immutable address; + %immutable firmware; + %immutable model; + %immutable numa_node; + %immutable queue_count; + %immutable serial; + %immutable sqsize; + %immutable persistent; + %immutable discovery_ctrl; + char *transport; + char *subsysnqn; + char *traddr; + char *trsvcid; + char *dhchap_key; + char *address; + char *firmware; + char *model; + char *numa_node; + char *queue_count; + char *serial; + char *sqsize; + bool persistent; + bool discovery_ctrl; +}; + +struct nvme_ns { + %immutable nsid; + %immutable eui64; + %immutable nguid; + %immutable uuid; + unsigned int nsid; + uint8_t eui64[8]; + uint8_t nguid[16]; + uint8_t uuid[16]; +}; + +%extend nvme_root { + nvme_root(const char *config_file = NULL) { + return nvme_scan(config_file); + } + ~nvme_root() { + nvme_free_tree($self); + } + void log_level(const char *level) { + int log_level = DEFAULT_LOGLEVEL; + if (!strcmp(level,"debug")) + log_level = LOG_DEBUG; + else if (!strcmp(level, "info")) + log_level = LOG_INFO; + else if (!strcmp(level, "notice")) + log_level = LOG_NOTICE; + else if (!strcmp(level, "warning")) + log_level = LOG_WARNING; + else if (!strcmp(level, "err")) + log_level = LOG_ERR; + else if (!strcmp(level, "crit")) + log_level = LOG_CRIT; + else if (!strcmp(level, "alert")) + log_level = LOG_ALERT; + else if (!strcmp(level, "emerg")) + log_level = LOG_EMERG; + nvme_init_logging($self, log_level, false, false); + } + struct nvme_host *hosts() { + return nvme_first_host($self); + } + void refresh_topology() { + nvme_refresh_topology($self); + } + void update_config() { + nvme_update_config($self); + } + void dump_config() { + nvme_dump_config($self); + } +} + +%extend host_iter { + struct host_iter *__iter__() { + return $self; + } + struct nvme_host *__next__() { + struct nvme_host *this = $self->pos; + + if (!this) { + host_iter_err = 1; + return NULL; + } + $self->pos = nvme_next_host($self->root, this); + return this; + } +} + +%extend nvme_host { + nvme_host(struct nvme_root *r, const char *hostnqn = NULL, + const char *hostid = NULL, const char *hostsymname = NULL) { + + nvme_host_t h = hostnqn ? nvme_lookup_host(r, hostnqn, hostid) : nvme_default_host(r); + if (hostsymname) + nvme_host_set_hostsymname(h, hostsymname); + return h; + } + ~nvme_host() { + nvme_free_host($self); + } +%define SET_SYMNAME_DOCSTRING +"@brief Set or Clear Host's Symbolic Name + +@param hostsymname: A symbolic name, or None to clear the symbolic name. +@type hostsymname: str|None + +@return: None" +%enddef + %feature("autodoc", SET_SYMNAME_DOCSTRING) set_symname; + void set_symname(const char *hostsymname) { + nvme_host_set_hostsymname($self, hostsymname); + } + char *__str__() { + static char tmp[2048]; + + sprintf(tmp, "nvme_host(%s,%s)", $self->hostnqn, $self->hostid); + return tmp; + } + struct host_iter __iter__() { + struct host_iter ret = { .root = nvme_host_get_root($self), + .pos = $self }; + return ret; + } + struct nvme_subsystem *subsystems() { + return nvme_first_subsystem($self); + } +} + +%extend subsystem_iter { + struct subsystem_iter *__iter__() { + return $self; + } + struct nvme_subsystem *__next__() { + struct nvme_subsystem *this = $self->pos; + + if (!this) { + subsys_iter_err = 1; + return NULL; + } + $self->pos = nvme_next_subsystem($self->host, this); + return this; + } +} + +%extend ns_iter { + struct ns_iter *__iter__() { + return $self; + } + struct nvme_ns *__next__() { + struct nvme_ns *this = $self->pos; + + if (!this) { + ns_iter_err = 1; + return NULL; + } + if ($self->ctrl) + $self->pos = nvme_ctrl_next_ns($self->ctrl, this); + else + $self->pos = nvme_subsystem_next_ns($self->subsystem, this); + return this; + } +} + +%extend nvme_subsystem { + nvme_subsystem(struct nvme_host *host, const char *subsysnqn, + const char *name = NULL) { + return nvme_lookup_subsystem(host, name, subsysnqn); + } + ~nvme_subsystem() { + nvme_free_subsystem($self); + } + char *__str__() { + static char tmp[1024]; + + sprintf(tmp, "nvme_subsystem(%s,%s)", $self->name,$self->subsysnqn); + return tmp; + } + struct subsystem_iter __iter__() { + struct subsystem_iter ret = { .host = nvme_subsystem_get_host($self), + .pos = $self }; + return ret; + } + struct nvme_ctrl *controllers() { + return nvme_subsystem_first_ctrl($self); + } + struct nvme_ns *namespaces() { + return nvme_subsystem_first_ns($self); + } + %immutable name; + const char *name; + %immutable host; + struct nvme_host *host; +} + +%{ + const char *nvme_subsystem_name_get(struct nvme_subsystem *s) { + return nvme_subsystem_get_name(s); + } + struct nvme_host *nvme_subsystem_host_get(struct nvme_subsystem *s) { + return nvme_subsystem_get_host(s); + } +%}; + +%extend ctrl_iter { + struct ctrl_iter *__iter__() { + return $self; + } + struct nvme_ctrl *__next__() { + struct nvme_ctrl *this = $self->pos; + + if (!this) { + ctrl_iter_err = 1; + return NULL; + } + $self->pos = nvme_subsystem_next_ctrl($self->subsystem, this); + return this; + } +} + +%extend nvme_ctrl { + nvme_ctrl(struct nvme_root *r, const char *subsysnqn, const char *transport, + const char *traddr = NULL, const char *host_traddr = NULL, + const char *host_iface = NULL, const char *trsvcid = NULL) { + return nvme_create_ctrl(r, subsysnqn, transport, traddr, + host_traddr, host_iface, trsvcid); + } + ~nvme_ctrl() { + nvme_free_ctrl($self); + } + + void discovery_ctrl_set(bool discovery) { + nvme_ctrl_set_discovery_ctrl($self, discovery); + } + + bool init(struct nvme_host *h, int instance) { + return nvme_init_ctrl(h, $self, instance) == 0; + } + + void connect(struct nvme_host *h, struct nvme_fabrics_config *cfg = NULL) { + int ret; + const char *dev; + + dev = nvme_ctrl_get_name($self); + if (dev && !cfg->duplicate_connect) { + connect_err = 1; + return; + } + ret = nvmf_add_ctrl(h, $self, cfg); + if (ret < 0) { + connect_err = 2; + return; + } + } + bool connected() { + return nvme_ctrl_get_name($self) != NULL; + } + void persistent_set(bool persistent) { + nvme_ctrl_set_persistent($self, persistent); + } + void rescan() { + nvme_rescan_ctrl($self); + } + void disconnect() { + nvme_disconnect_ctrl($self); + } + + %feature("autodoc", "@return: True if controller supports explicit registration. False otherwise.") is_registration_supported; + bool is_registration_supported() { + return nvmf_is_registration_supported($self); + } + + %feature("autodoc", "@return None on success or Error string on error.") registration_ctlr; + PyObject *registration_ctlr(enum nvmf_dim_tas tas) { + __u32 result; + int status; + + status = nvmf_register_ctrl($self, NVMF_DIM_TAS_REGISTER, &result); + if (status != NVME_SC_SUCCESS) { + /* On error, return an error message */ + if (status < 0) + return PyUnicode_FromFormat("Status:0x%04x - %s", status, nvme_status_to_string(status, false)); + else + return PyUnicode_FromFormat("Result:0x%04x, Status:0x%04x - %s", result, status, nvme_status_to_string(status, false)); + } + + /* On success, return None */ + Py_RETURN_NONE; + } + + %newobject discover; + struct nvmf_discovery_log *discover(int max_retries = 6) { + struct nvmf_discovery_log *logp = NULL; + int ret = 0; + ret = nvmf_get_discovery_log($self, &logp, max_retries); + if (ret < 0) { + discover_err = 1; + return NULL; + } + return logp; + } + char *__str__() { + static char tmp[1024]; + + if ($self->address) + sprintf(tmp, "nvme_ctrl(transport=%s,%s)", $self->transport, + $self->address); + else + sprintf(tmp, "nvme_ctrl(transport=%s)", $self->transport); + return tmp; + } + struct ctrl_iter __iter__() { + struct ctrl_iter ret = { .subsystem = nvme_ctrl_get_subsystem($self), + .pos = $self }; + return ret; + } + struct nvme_ns *namespaces() { + return nvme_ctrl_first_ns($self); + } + %immutable name; + const char *name; + %immutable subsystem; + struct nvme_subsystem *subsystem; + %immutable state; + const char *state; +} + +%{ + const char *nvme_ctrl_name_get(struct nvme_ctrl *c) { + return nvme_ctrl_get_name(c); + } + struct nvme_subsystem *nvme_ctrl_subsystem_get(struct nvme_ctrl *c) { + return nvme_ctrl_get_subsystem(c); + } + const char *nvme_ctrl_state_get(struct nvme_ctrl *c) { + return nvme_ctrl_get_state(c); + } +%}; + +%extend nvme_ns { + nvme_ns(struct nvme_subsystem *s, unsigned int nsid) { + return nvme_subsystem_lookup_namespace(s, nsid); + } + ~nvme_ns() { + nvme_free_ns($self); + } + char *__str__() { + static char tmp[1024]; + + sprintf(tmp, "nvme_ns(%u)", $self->nsid); + return tmp; + } + struct ns_iter __iter__() { + struct ns_iter ret = { .ctrl = nvme_ns_get_ctrl($self), + .subsystem = nvme_ns_get_subsystem($self), + .pos = $self }; + return ret; + } + %immutable name; + const char *name; +} + +%{ + const char *nvme_ns_name_get(struct nvme_ns *n) { + return nvme_ns_get_name(n); + } +%}; + + +// We want to swig all the #define and enum from types.h, but none of the structs. +%{ +#include "nvme/types.h" +%} +#define __attribute__(x) +%rename($ignore, %$isclass) ""; // ignore all classes/structs +%rename($ignore, %$isfunction) ""; // ignore all functions +%rename($ignore, %$isunion) ""; // ignore all unions +%rename($ignore, %$isvariable ) ""; // ignore all variables + +%include "../src/nvme/types.h" diff --git a/libnvme/tests/create-ctrl-obj.py b/libnvme/tests/create-ctrl-obj.py new file mode 100755 index 0000000..51915cc --- /dev/null +++ b/libnvme/tests/create-ctrl-obj.py @@ -0,0 +1,14 @@ +#!/usr/bin/env python3 +import sys +import pprint +from libnvme import nvme + +root = nvme.root() +root.log_level('debug') + +host = nvme.host(root) +subsysnqn = nvme.NVME_DISC_SUBSYS_NAME +transport = 'loop' +traddr = '127.0.0.1' +trsvcid = '8009' +ctrl = nvme.ctrl(root, subsysnqn=subsysnqn, transport=transport, traddr=traddr, trsvcid=trsvcid) diff --git a/meson.build b/meson.build new file mode 100644 index 0000000..da7d05e --- /dev/null +++ b/meson.build @@ -0,0 +1,176 @@ +# SPDX-License-Identifier: LGPL-2.1-or-later +# +# This file is part of libnvme. +# Copyright (c) 2021 Dell Inc. +# +# Authors: Martin Belanger <Martin.Belanger@dell.com> +# +project( + 'libnvme', ['c', 'cpp'], + meson_version: '>= 0.47.0', + version: '1.0', + license: 'LGPLv2+', + default_options: [ + 'c_std=gnu99', + 'warning_level=1', + 'buildtype=release', + 'prefix=/usr', + ] +) + +library_version = meson.project_version() + '.0' + +################################################################################ +cc = meson.get_compiler('c') + +prefixdir = get_option('prefix') +libdir = join_paths(prefixdir, get_option('libdir')) +includedir = join_paths(prefixdir, get_option('includedir')) +datadir = join_paths(prefixdir, get_option('datadir')) +mandir = join_paths(prefixdir, get_option('mandir')) +bindir = join_paths(prefixdir, get_option('bindir')) +sysconfdir = join_paths(prefixdir, get_option('sysconfdir')) + +pkgconfiglibdir = get_option('pkgconfiglibdir') == '' ? join_paths(libdir, 'pkgconfig') : get_option('pkgconfiglibdir') + +################################################################################ +conf = configuration_data() + +conf.set('SYSCONFDIR', '"@0@"'.format(sysconfdir)) + +# Check for libuuid availability +libuuid_dep = dependency('uuid', required: true) +conf.set('CONFIG_LIBUUID', libuuid_dep.found(), description: 'Is libuuid required?') + +# Check for json-c availability +json_c_dep = dependency('json-c', + version: '>=0.13', + required: true, + fallback : ['json-c', 'json_c_dep']) +conf.set('CONFIG_JSONC', json_c_dep.found(), description: 'Is json-c required?') + +# Check for OpenSSL availability +openssl_dep = dependency('openssl', + version: '>=1.1.0', + required: get_option('openssl'), + fallback : ['openssl', 'libssl_dep']) +if openssl_dep.found() + conf.set('CONFIG_OPENSSL', true, description: 'Is OpenSSL available?') + conf.set('CONFIG_OPENSSL_1', + openssl_dep.version().version_compare('<2.0.0') and + openssl_dep.version().version_compare('>=1.1.0'), + description: 'OpenSSL version 1.x') + conf.set('CONFIG_OPENSSL_3', + openssl_dep.version().version_compare('>=3.0.0'), + description: 'OpenSSL version 3.x') +endif + +# local (cross-compilable) implementations of ccan configure steps +conf.set10( + 'HAVE_BUILTIN_TYPES_COMPATIBLE_P', + cc.compiles( + '''int main(void) { + return __builtin_types_compatible_p(int, long); + } + ''', + name: '__builtin_type_compatible_p' + ), + description: 'Is __builtin_types_compatible_p available?' +) +conf.set10( + 'HAVE_TYPEOF', + cc.compiles( + '''int main(void) { + int a = 1; + typeof(a) b; + b = a; + } + ''', + name: 'typeof' + ), + description: 'Is typeof available?' +) +conf.set10( + 'HAVE_BYTESWAP_H', + cc.compiles( + '''#include <byteswap.h>''', + name: 'byteswap.h' + ), + description: 'Is byteswap.h include-able?' +) +conf.set10( + 'HAVE_BSWAP_64', + cc.links( + '''#include <byteswap.h> + int main(void) { + return bswap_64(0); + } + ''', + name: 'bswap64' + ), + description: 'Is bswap_64 available?' +) +conf.set10( + 'HAVE_LITTLE_ENDIAN', + build_machine.endian() == 'little', + description: 'Building for little-endian' +) +conf.set10( + 'HAVE_BIG_ENDIAN', + build_machine.endian() == 'big', + description: 'Building for big-endian' +) +conf.set10( + 'HAVE_STATEMENT_EXPR', + cc.compiles( + '''int main(int argc, char **argv) { + return ({ int x = argc; x == 1; }); + } + ''', + name: 'statement-expr' + ), + description: 'Can we use a statement as an expression?' +) +conf.set10( + 'HAVE_ISBLANK', + cc.links( + '''#include <ctype.h> + int main(int argc, char **argv) { + return isblank(argv[0][0]); + } + ''', + name: 'isblank' + ), + description: 'Is isblank() available?' +) + +################################################################################ +substs = configuration_data() +substs.set('NAME', meson.project_name()) +substs.set('VERSION', meson.project_version()) +substs.set('LICENSE', meson.project_license()[0]) +configure_file( + input: 'libnvme.spec.in', + output: 'libnvme.spec', + configuration: substs, +) + +################################################################################ +add_project_arguments( + [ + '-fomit-frame-pointer', + '-D_GNU_SOURCE', + '-include', 'internal/config.h', + ], + language : 'c', +) +incdir = include_directories(['.', 'ccan', 'src']) + +################################################################################ +subdir('internal') +subdir('ccan') +subdir('src') +subdir('libnvme') +subdir('test') +subdir('examples') +subdir('doc') diff --git a/meson_options.txt b/meson_options.txt new file mode 100644 index 0000000..f5cac6e --- /dev/null +++ b/meson_options.txt @@ -0,0 +1,9 @@ +# -*- mode: meson -*- +option('pkgconfiglibdir', type : 'string', value : '', description : 'directory for standard pkg-config files') +option('htmldir', type : 'string', value : '', description : 'directory for HTML documentation') + +option('docs', type : 'combo', choices : ['false', 'html', 'man', 'all'], description : 'install documentation') +option('docs-build', type : 'boolean', value : false, description : 'build documentation') + +option('python', type : 'combo', choices : ['auto', 'true', 'false'], description : 'Generate libnvme python bindings') +option('openssl', type : 'feature', value: 'auto', description : 'OpenSSL support') diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..5681e77 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,24 @@ +[build-system] +requires = ["mesonpep517", "wheel", "meson==0.61.2", "ninja"] # PEP 508 specifications. +build-backend = "mesonpep517.buildapi" + +[tool.mesonpep517.metadata] +author="Hannes Reinecke" +author-email="hare@suse.de" +classifiers = [ + "Intended Audience :: Developers", + "Development Status :: 5 - Production/Stable", + "License :: OSI Approved :: GNU Lesser General Public License v2 or later (LGPLv2+)", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.6", + "Programming Language :: Python :: 3.7", + "Programming Language :: Python :: 3.8", + "Programming Language :: Python :: 3.9", + "Topic :: Software Development :: Libraries :: Python Modules", +] +description-file="README.md" +home-page = "https://github.com/linux-nvme/libnvme" +license="LGPL-2.1-or-later" +requires-python=">=3.6" +summary="python bindings for libnvme" + diff --git a/src/libnvme.h b/src/libnvme.h new file mode 100644 index 0000000..6be9058 --- /dev/null +++ b/src/libnvme.h @@ -0,0 +1,30 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/* + * This file is part of libnvme. + * Copyright (c) 2020 Western Digital Corporation or its affiliates. + * + * Authors: Keith Busch <keith.busch@wdc.com> + * Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com> + */ + +#ifndef _LIBNVME_H +#define _LIBNVME_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "nvme/types.h" +#include "nvme/linux.h" +#include "nvme/ioctl.h" +#include "nvme/fabrics.h" +#include "nvme/filters.h" +#include "nvme/tree.h" +#include "nvme/util.h" +#include "nvme/log.h" + +#ifdef __cplusplus +} +#endif + +#endif /* _LIBNVME_H */ diff --git a/src/libnvme.map b/src/libnvme.map new file mode 100644 index 0000000..087dc66 --- /dev/null +++ b/src/libnvme.map @@ -0,0 +1,341 @@ +LIBNVME_1_0 { + global: + nvme_admin_passthru64; + nvme_admin_passthru; + nvme_attach_ns; + nvme_capacity_mgmt; + nvme_compare; + nvme_copy; + nvme_create_root; + nvme_create_ctrl; + nvme_ctrl_disconnect; + nvme_ctrl_first_ns; + nvme_ctrl_first_path; + nvme_ctrl_get_address; + nvme_ctrl_get_dhchap_key; + nvme_ctrl_get_discovery_ctrl; + nvme_ctrl_get_fd; + nvme_ctrl_get_firmware; + nvme_ctrl_get_host_iface; + nvme_ctrl_get_host_traddr; + nvme_ctrl_get_model; + nvme_ctrl_get_name; + nvme_ctrl_get_numa_node; + nvme_ctrl_get_queue_count; + nvme_ctrl_get_serial; + nvme_ctrl_get_sqsize; + nvme_ctrl_get_state; + nvme_ctrl_get_subsysnqn; + nvme_ctrl_get_subsystem; + nvme_ctrl_get_sysfs_dir; + nvme_ctrl_get_traddr; + nvme_ctrl_get_transport; + nvme_ctrl_get_trsvcid; + nvme_ctrl_identify; + nvme_ctrl_is_discovery_ctrl; + nvme_ctrl_next_ns; + nvme_ctrl_next_path; + nvme_ctrl_reset; + nvme_ctrl_set_dhchap_key; + nvme_ctrl_set_discovery_ctrl; + nvme_ctrl_set_persistent; + nvme_ctrls_filter; + nvme_default_host; + nvme_dev_self_test; + nvme_dim_send; + nvme_directive_recv; + nvme_directive_recv_identify_parameters; + nvme_directive_recv_stream_allocate; + nvme_directive_recv_stream_parameters; + nvme_directive_recv_stream_status; + nvme_directive_send; + nvme_directive_send_id_endir; + nvme_directive_send_stream_release_identifier; + nvme_directive_send_stream_release_resource; + nvme_disconnect_ctrl; + nvme_dsm; + nvme_dsm_range; + nvme_dump_config; + nvme_errno_to_string; + nvme_first_host; + nvme_first_subsystem; + nvme_flush; + nvme_format_nvm; + nvme_free_ctrl; + nvme_free_host; + nvme_free_ns; + nvme_free_subsystem; + nvme_free_tree; + nvme_fw_commit; + nvme_fw_download; + nvme_fw_download_seq; + nvme_gen_dhchap_key; + nvme_get_ana_log_len; + nvme_get_attr; + nvme_get_ctrl_attr; + nvme_get_ctrl_telemetry; + nvme_get_directive_receive_length; + nvme_get_feature_length; + nvme_get_features; + nvme_get_features_arbitration; + nvme_get_features_async_event; + nvme_get_features_auto_pst; + nvme_get_features_endurance_event_cfg; + nvme_get_features_err_recovery; + nvme_get_features_hctm; + nvme_get_features_host_behavior; + nvme_get_features_host_id; + nvme_get_features_host_mem_buf; + nvme_get_features_irq_coalesce; + nvme_get_features_irq_config; + nvme_get_features_kato; + nvme_get_features_lba_range; + nvme_get_features_lba_sts_interval; + nvme_get_features_nopsc; + nvme_get_features_num_queues; + nvme_get_features_plm_config; + nvme_get_features_plm_window; + nvme_get_features_power_mgmt; + nvme_get_features_resv_mask; + nvme_get_features_resv_persist; + nvme_get_features_rrl; + nvme_get_features_sanitize; + nvme_get_features_sw_progress; + nvme_get_features_temp_thresh; + nvme_get_features_timestamp; + nvme_get_features_volatile_wc; + nvme_get_features_write_atomic; + nvme_get_features_write_protect; + nvme_get_host_telemetry; + nvme_get_lba_status; + nvme_get_log; + nvme_get_log_ana; + nvme_get_log_ana_groups; + nvme_get_log_boot_partition; + nvme_get_log_changed_ns_list; + nvme_get_log_cmd_effects; + nvme_get_log_create_telemetry_host; + nvme_get_log_device_self_test; + nvme_get_log_discovery; + nvme_get_log_endurance_group; + nvme_get_log_endurance_grp_evt; + nvme_get_log_error; + nvme_get_log_fid_supported_effects; + nvme_get_log_fw_slot; + nvme_get_log_lba_status; + nvme_get_log_page; + nvme_get_log_persistent_event; + nvme_get_log_predictable_lat_event; + nvme_get_log_predictable_lat_nvmset; + nvme_get_log_reservation; + nvme_get_log_sanitize; + nvme_get_log_smart; + nvme_get_log_supported_log_pages; + nvme_get_log_telemetry_ctrl; + nvme_get_log_telemetry_host; + nvme_get_log_zns_changed_zones; + nvme_get_logical_block_size; + nvme_get_new_host_telemetry; + nvme_get_ns_attr; + nvme_get_nsid; + nvme_get_path_attr; + nvme_get_property; + nvme_get_subsys_attr; + nvme_get_telemetry_log; + nvme_host_get_dhchap_key; + nvme_host_get_hostid; + nvme_host_get_hostnqn; + nvme_host_get_hostsymname; + nvme_host_get_root; + nvme_host_set_dhchap_key; + nvme_host_set_hostsymname; + nvme_identify; + nvme_identify_active_ns_list; + nvme_identify_allocated_ns; + nvme_identify_allocated_ns_list; + nvme_identify_ctrl; + nvme_identify_ctrl_list; + nvme_identify_domain_list; + nvme_identify_endurance_group_list; + nvme_identify_independent_identify_ns; + nvme_identify_ns_csi_user_data_format; + nvme_identify_iocs_ns_csi_user_data_format; + nvme_identify_iocs; + nvme_identify_ns; + nvme_identify_ns_descs; + nvme_identify_ns_granularity; + nvme_identify_nsid_ctrl_list; + nvme_identify_nvmset_list; + nvme_identify_primary_ctrl; + nvme_identify_secondary_ctrl_list; + nvme_identify_uuid; + nvme_init_copy_range; + nvme_init_ctrl; + nvme_init_ctrl_list; + nvme_init_dsm_range; + nvme_init_logging; + nvme_io; + nvme_io_passthru64; + nvme_io_passthru; + nvme_lockdown; + nvme_lookup_ctrl; + nvme_lookup_host; + nvme_lookup_subsystem; + nvme_namespace_attach_ctrls; + nvme_namespace_detach_ctrls; + nvme_namespace_filter; + nvme_namespace_first_path; + nvme_namespace_next_path; + nvme_next_host; + nvme_next_subsystem; + nvme_ns_attach; + nvme_ns_attach_ctrls; + nvme_ns_compare; + nvme_ns_detach_ctrls; + nvme_ns_dettach_ctrls; + nvme_ns_flush; + nvme_ns_get_csi; + nvme_ns_get_ctrl; + nvme_ns_get_eui64; + nvme_ns_get_fd; + nvme_ns_get_firmware; + nvme_ns_get_generic_name; + nvme_ns_get_lba_count; + nvme_ns_get_lba_size; + nvme_ns_get_lba_util; + nvme_ns_get_meta_size; + nvme_ns_get_model; + nvme_ns_get_model; + nvme_ns_get_name; + nvme_ns_get_nguid; + nvme_ns_get_nsid; + nvme_ns_get_serial; + nvme_ns_get_subsystem; + nvme_ns_get_sysfs_dir; + nvme_ns_get_uuid; + nvme_ns_identify; + nvme_ns_mgmt; + nvme_ns_mgmt_create; + nvme_ns_mgmt_delete; + nvme_ns_open; + nvme_ns_read; + nvme_ns_rescan; + nvme_ns_verify; + nvme_ns_write; + nvme_ns_write_uncorrectable; + nvme_ns_write_zeros; + nvme_nvm_identify_ctrl; + nvme_open; + nvme_path_get_ana_state; + nvme_path_get_ctrl; + nvme_path_get_name; + nvme_path_get_ns; + nvme_path_get_sysfs_dir; + nvme_paths_filter; + nvme_read; + nvme_read_config; + nvme_refresh_topology; + nvme_rescan_ctrl; + nvme_resv_acquire; + nvme_resv_register; + nvme_resv_release; + nvme_resv_report; + nvme_sanitize; + nvme_sanitize_nvm; + nvme_scan; + nvme_scan_ctrl; + nvme_scan_ctrl_namespace_paths; + nvme_scan_ctrl_namespaces; + nvme_scan_topology; + nvme_scan_namespace; + nvme_scan_subsystem_namespaces; + nvme_scan_subsystems; + nvme_security_receive; + nvme_security_receive; + nvme_security_send; + nvme_set_feature; + nvme_set_features; + nvme_set_features_arbitration; + nvme_set_features_async_event; + nvme_set_features_auto_pst; + nvme_set_features_endurance_evt_cfg; + nvme_set_features_err_recovery; + nvme_set_features_hctm; + nvme_set_features_host_behavior; + nvme_set_features_host_id; + nvme_set_features_irq_coalesce; + nvme_set_features_irq_config; + nvme_set_features_lba_range; + nvme_set_features_lba_sts_interval; + nvme_set_features_nopsc; + nvme_set_features_plm_config; + nvme_set_features_plm_window; + nvme_set_features_power_mgmt; + nvme_set_features_resv_mask; + nvme_set_features_resv_persist; + nvme_set_features_rrl; + nvme_set_features_sanitize; + nvme_set_features_sw_progress; + nvme_set_features_temp_thresh; + nvme_set_features_timestamp; + nvme_set_features_volatile_wc; + nvme_set_features_write_atomic; + nvme_set_features_write_protect; + nvme_set_property; + nvme_setup_ctrl_list; + nvme_setup_id_ns; + nvme_status_to_errno; + nvme_status_to_string; + nvme_status_type; + nvme_submit_admin_passthru64; + nvme_submit_admin_passthru; + nvme_submit_io_passthru64; + nvme_submit_io_passthru; + nvme_subsys_filter; + nvme_subsystem_first_ctrl; + nvme_subsystem_first_ns; + nvme_subsystem_get_host; + nvme_subsystem_get_name; + nvme_subsystem_get_nqn; + nvme_subsystem_get_sysfs_dir; + nvme_subsystem_get_type; + nvme_subsystem_lookup_namespace; + nvme_subsystem_next_ctrl; + nvme_subsystem_next_ns; + nvme_subsystem_reset; + nvme_unlink_ctrl; + nvme_update_config; + nvme_verify; + nvme_virtual_mgmt; + nvme_write; + nvme_write_uncorrectable; + nvme_write_zeros; + nvme_zns_append; + nvme_zns_identify_ctrl; + nvme_zns_identify_ns; + nvme_zns_identify_ns; + nvme_zns_mgmt_recv; + nvme_zns_mgmt_send; + nvme_zns_report_zones; + nvmf_add_ctrl; + nvmf_adrfam_str; + nvmf_cms_str; + nvmf_connect_disc_entry; + nvmf_default_config; + nvmf_eflags_str; + nvmf_get_discovery_log; + nvmf_hostid_from_file; + nvmf_hostnqn_from_file; + nvmf_hostnqn_generate; + nvmf_is_registration_supported; + nvmf_prtype_str; + nvmf_qptype_str; + nvmf_register_ctrl; + nvmf_sectype_str; + nvmf_subtype_str; + nvmf_treq_str; + nvmf_trtype_str; + nvmf_update_config; + local: + *; +}; diff --git a/src/licenses/BSD-MIT b/src/licenses/BSD-MIT new file mode 100644 index 0000000..89de354 --- /dev/null +++ b/src/licenses/BSD-MIT @@ -0,0 +1,17 @@ +Permission 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. diff --git a/src/licenses/CC0 b/src/licenses/CC0 new file mode 100644 index 0000000..feb9b11 --- /dev/null +++ b/src/licenses/CC0 @@ -0,0 +1,28 @@ +Statement 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. diff --git a/src/meson.build b/src/meson.build new file mode 100644 index 0000000..b573b19 --- /dev/null +++ b/src/meson.build @@ -0,0 +1,74 @@ +# SPDX-License-Identifier: LGPL-2.1-or-later +# +# This file is part of libnvme. +# Copyright (c) 2021 Dell Inc. +# +# Authors: Martin Belanger <Martin.Belanger@dell.com> +# +sources = [ + 'nvme/cleanup.c', + 'nvme/fabrics.c', + 'nvme/filters.c', + 'nvme/ioctl.c', + 'nvme/linux.c', + 'nvme/log.c', + 'nvme/tree.c', + 'nvme/util.c', +] + +if conf.get('CONFIG_JSONC') + sources += 'nvme/json.c' +endif + +deps = [ + libuuid_dep, + json_c_dep, + openssl_dep, +] + +source_dir = meson.current_source_dir() +mapfile = 'libnvme.map' +version_script_arg = join_paths(source_dir, mapfile) + +libnvme = library( + 'nvme', # produces libnvme.so + sources, + version: library_version, + link_args: ['-Wl,--version-script=' + version_script_arg], + dependencies: deps, + link_depends: mapfile, + include_directories: [incdir, internal_incdir], + install: true, + link_with: libccan, +) + +pkg = import('pkgconfig') +pkg.generate(libnvme, + filebase: meson.project_name(), + name: meson.project_name(), + version: meson.project_version(), + description: 'Manage "libnvme" subsystem devices (Non-volatile Memory Express)', + url: 'http://github.com/linux-nvme/libnvme/', +) + +libnvme_dep = declare_dependency( + include_directories: ['.'], + dependencies: deps, + link_with: libnvme, +) + +mode = ['rw-r--r--', 0, 0] +install_headers('libnvme.h', install_mode: mode) +install_headers([ + 'nvme/fabrics.h', + 'nvme/filters.h', + 'nvme/ioctl.h', + 'nvme/linux.h', + 'nvme/log.h', + 'nvme/tree.h', + 'nvme/types.h', + 'nvme/util.h', + ], + subdir: 'nvme', + install_mode: mode, +) diff --git a/src/nvme/cleanup.c b/src/nvme/cleanup.c new file mode 100644 index 0000000..0d5d910 --- /dev/null +++ b/src/nvme/cleanup.c @@ -0,0 +1,4 @@ +#include <stdlib.h> +#include "cleanup.h" + +DEFINE_CLEANUP_FUNC(cleanup_charp, char *, free); diff --git a/src/nvme/cleanup.h b/src/nvme/cleanup.h new file mode 100644 index 0000000..89a4984 --- /dev/null +++ b/src/nvme/cleanup.h @@ -0,0 +1,18 @@ +#ifndef __CLEANUP_H +#define __CLEANUP_H + +#define __cleanup__(fn) __attribute__((cleanup(fn))) + +#define DECLARE_CLEANUP_FUNC(name, type) \ + void name(type *__p) + +#define DEFINE_CLEANUP_FUNC(name, type, free_fn)\ +DECLARE_CLEANUP_FUNC(name, type) \ +{ \ + if (*__p) \ + free_fn(*__p); \ +} + +DECLARE_CLEANUP_FUNC(cleanup_charp, char *); + +#endif diff --git a/src/nvme/fabrics.c b/src/nvme/fabrics.c new file mode 100644 index 0000000..2a26843 --- /dev/null +++ b/src/nvme/fabrics.c @@ -0,0 +1,1310 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/* + * This file is part of libnvme. + * Copyright (c) 2020 Western Digital Corporation or its affiliates. + * + * Authors: Keith Busch <keith.busch@wdc.com> + * Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com> + */ + +#include <ctype.h> +#include <errno.h> +#include <fcntl.h> +#include <limits.h> +#include <stdbool.h> +#include <stddef.h> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <unistd.h> +#include <dirent.h> +#include <inttypes.h> + +#include <sys/param.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <arpa/inet.h> +#include <netdb.h> +#include <net/if.h> + +#include <ccan/endian/endian.h> +#include <ccan/list/list.h> +#include <ccan/array_size/array_size.h> + +#include "fabrics.h" +#include "linux.h" +#include "ioctl.h" +#include "util.h" +#include "log.h" +#include "private.h" + +#define NVMF_HOSTID_SIZE 37 +#define UUID_SIZE 37 /* 1b4e28ba-2fa1-11d2-883f-0016d3cca427 + \0 */ + +#define NVMF_HOSTNQN_FILE SYSCONFDIR "/nvme/hostnqn" +#define NVMF_HOSTID_FILE SYSCONFDIR "/nvme/hostid" + +const char *nvmf_dev = "/dev/nvme-fabrics"; + +/** + * strchomp() - Strip trailing white space + * @s: String to strip + * @l: Maximum length of string + */ +static void strchomp(char *s, int l) +{ + while (l && (s[l] == '\0' || s[l] == ' ')) + s[l--] = '\0'; +} + +const char *arg_str(const char * const *strings, + size_t array_size, size_t idx) +{ + if (idx < array_size && strings[idx]) + return strings[idx]; + return "unrecognized"; +} + +const char * const trtypes[] = { + [NVMF_TRTYPE_RDMA] = "rdma", + [NVMF_TRTYPE_FC] = "fc", + [NVMF_TRTYPE_TCP] = "tcp", + [NVMF_TRTYPE_LOOP] = "loop", +}; + +const char *nvmf_trtype_str(__u8 trtype) +{ + return arg_str(trtypes, ARRAY_SIZE(trtypes), trtype); +} + +static const char * const adrfams[] = { + [NVMF_ADDR_FAMILY_PCI] = "pci", + [NVMF_ADDR_FAMILY_IP4] = "ipv4", + [NVMF_ADDR_FAMILY_IP6] = "ipv6", + [NVMF_ADDR_FAMILY_IB] = "infiniband", + [NVMF_ADDR_FAMILY_FC] = "fibre-channel", +}; + +const char *nvmf_adrfam_str(__u8 adrfam) +{ + return arg_str(adrfams, ARRAY_SIZE(adrfams), adrfam); +} + +static const char * const subtypes[] = { + [NVME_NQN_DISC] = "discovery subsystem referral", + [NVME_NQN_NVME] = "nvme subsystem", + [NVME_NQN_CURR] = "current discovery subsystem", +}; + +const char *nvmf_subtype_str(__u8 subtype) +{ + return arg_str(subtypes, ARRAY_SIZE(subtypes), subtype); +} + +static const char * const treqs[] = { + [NVMF_TREQ_NOT_SPECIFIED] = "not specified", + [NVMF_TREQ_REQUIRED] = "required", + [NVMF_TREQ_NOT_REQUIRED] = "not required", + [NVMF_TREQ_DISABLE_SQFLOW] = "not specified, " + "sq flow control disable supported", +}; + +const char *nvmf_treq_str(__u8 treq) +{ + return arg_str(treqs, ARRAY_SIZE(treqs), treq); +} + +static const char * const eflags_strings[] = { + [NVMF_DISC_EFLAGS_NONE] = "not specified", + [NVMF_DISC_EFLAGS_EPCSD] = "explicit discovery connections", + [NVMF_DISC_EFLAGS_DUPRETINFO] = "duplicate discovery information", + [NVMF_DISC_EFLAGS_BOTH] = "explicit discovery connections, " + "duplicate discovery information", +}; + +const char *nvmf_eflags_str(__u16 eflags) +{ + return arg_str(eflags_strings, ARRAY_SIZE(eflags_strings), eflags); +} + +static const char * const sectypes[] = { + [NVMF_TCP_SECTYPE_NONE] = "none", + [NVMF_TCP_SECTYPE_TLS] = "tls", + [NVMF_TCP_SECTYPE_TLS13] = "tls13", +}; + +const char *nvmf_sectype_str(__u8 sectype) +{ + return arg_str(sectypes, ARRAY_SIZE(sectypes), sectype); +} + +static const char * const prtypes[] = { + [NVMF_RDMA_PRTYPE_NOT_SPECIFIED] = "not specified", + [NVMF_RDMA_PRTYPE_IB] = "infiniband", + [NVMF_RDMA_PRTYPE_ROCE] = "roce", + [NVMF_RDMA_PRTYPE_ROCEV2] = "roce-v2", + [NVMF_RDMA_PRTYPE_IWARP] = "iwarp", +}; + +const char *nvmf_prtype_str(__u8 prtype) +{ + return arg_str(prtypes, ARRAY_SIZE(prtypes), prtype); +} + +static const char * const qptypes[] = { + [NVMF_RDMA_QPTYPE_CONNECTED] = "connected", + [NVMF_RDMA_QPTYPE_DATAGRAM] = "datagram", +}; + +const char *nvmf_qptype_str(__u8 qptype) +{ + return arg_str(qptypes, ARRAY_SIZE(qptypes), qptype); +} + +static const char * const cms[] = { + [NVMF_RDMA_CMS_RDMA_CM] = "rdma-cm", +}; + +const char *nvmf_cms_str(__u8 cm) +{ + return arg_str(cms, ARRAY_SIZE(cms), cm); +} + +void nvmf_default_config(struct nvme_fabrics_config *cfg) +{ + memset(cfg, 0, sizeof(*cfg)); + cfg->tos = -1; + cfg->ctrl_loss_tmo = NVMF_DEF_CTRL_LOSS_TMO; +} + +#define MERGE_CFG_OPTION(c, n, o, d) \ + if ((c)->o == d) (c)->o = (n)->o +static struct nvme_fabrics_config *merge_config(nvme_ctrl_t c, + const struct nvme_fabrics_config *cfg) +{ + struct nvme_fabrics_config *ctrl_cfg = nvme_ctrl_get_config(c); + + MERGE_CFG_OPTION(ctrl_cfg, cfg, host_traddr, NULL); + MERGE_CFG_OPTION(ctrl_cfg, cfg, host_iface, NULL); + MERGE_CFG_OPTION(ctrl_cfg, cfg, nr_io_queues, 0); + MERGE_CFG_OPTION(ctrl_cfg, cfg, nr_write_queues, 0); + MERGE_CFG_OPTION(ctrl_cfg, cfg, nr_poll_queues, 0); + MERGE_CFG_OPTION(ctrl_cfg, cfg, queue_size, 0); + MERGE_CFG_OPTION(ctrl_cfg, cfg, keep_alive_tmo, 0); + MERGE_CFG_OPTION(ctrl_cfg, cfg, reconnect_delay, 0); + MERGE_CFG_OPTION(ctrl_cfg, cfg, ctrl_loss_tmo, + NVMF_DEF_CTRL_LOSS_TMO); + MERGE_CFG_OPTION(ctrl_cfg, cfg, fast_io_fail_tmo, 0); + MERGE_CFG_OPTION(ctrl_cfg, cfg, tos, -1); + MERGE_CFG_OPTION(ctrl_cfg, cfg, duplicate_connect, false); + MERGE_CFG_OPTION(ctrl_cfg, cfg, disable_sqflow, false); + MERGE_CFG_OPTION(ctrl_cfg, cfg, hdr_digest, false); + MERGE_CFG_OPTION(ctrl_cfg, cfg, data_digest, false); + MERGE_CFG_OPTION(ctrl_cfg, cfg, tls, false); + + return ctrl_cfg; +} + +#define UPDATE_CFG_OPTION(c, n, o, d) \ + if ((n)->o != d) (c)->o = (n)->o +void nvmf_update_config(nvme_ctrl_t c, const struct nvme_fabrics_config *cfg) +{ + struct nvme_fabrics_config *ctrl_cfg = nvme_ctrl_get_config(c); + + UPDATE_CFG_OPTION(ctrl_cfg, cfg, host_traddr, NULL); + UPDATE_CFG_OPTION(ctrl_cfg, cfg, host_iface, NULL); + UPDATE_CFG_OPTION(ctrl_cfg, cfg, nr_io_queues, 0); + UPDATE_CFG_OPTION(ctrl_cfg, cfg, nr_write_queues, 0); + UPDATE_CFG_OPTION(ctrl_cfg, cfg, nr_poll_queues, 0); + UPDATE_CFG_OPTION(ctrl_cfg, cfg, queue_size, 0); + UPDATE_CFG_OPTION(ctrl_cfg, cfg, keep_alive_tmo, 0); + UPDATE_CFG_OPTION(ctrl_cfg, cfg, reconnect_delay, 0); + UPDATE_CFG_OPTION(ctrl_cfg, cfg, ctrl_loss_tmo, + NVMF_DEF_CTRL_LOSS_TMO); + UPDATE_CFG_OPTION(ctrl_cfg, cfg, fast_io_fail_tmo, 0); + UPDATE_CFG_OPTION(ctrl_cfg, cfg, tos, -1); + UPDATE_CFG_OPTION(ctrl_cfg, cfg, duplicate_connect, false); + UPDATE_CFG_OPTION(ctrl_cfg, cfg, disable_sqflow, false); + UPDATE_CFG_OPTION(ctrl_cfg, cfg, hdr_digest, false); + UPDATE_CFG_OPTION(ctrl_cfg, cfg, data_digest, false); + UPDATE_CFG_OPTION(ctrl_cfg, cfg, tls, false); +} + +static int add_bool_argument(char **argstr, char *tok, bool arg) +{ + char *nstr; + + if (!arg) + return 0; + if (asprintf(&nstr, "%s,%s", *argstr, tok) < 0) { + errno = ENOMEM; + return -1; + } + free(*argstr); + *argstr = nstr; + + return 0; +} + +static int add_int_argument(char **argstr, char *tok, int arg, bool allow_zero) +{ + char *nstr; + + if (arg < 0 || (!arg && !allow_zero)) + return 0; + if (asprintf(&nstr, "%s,%s=%d", *argstr, tok, arg) < 0) { + errno = ENOMEM; + return -1; + } + free(*argstr); + *argstr = nstr; + + return 0; +} + +static int add_int_or_minus_one_argument(char **argstr, char *tok, int arg) +{ + char *nstr; + + if (arg < -1) + return 0; + if (asprintf(&nstr, "%s,%s=%d", *argstr, tok, arg) < 0) { + errno = ENOMEM; + return -1; + } + free(*argstr); + *argstr = nstr; + + return 0; +} + +static int add_argument(char **argstr, const char *tok, const char *arg) +{ + char *nstr; + + if (!(arg && strcmp(arg, "none"))) + return 0; + if (asprintf(&nstr, "%s,%s=%s", *argstr, tok, arg) < 0) { + errno = ENOMEM; + return -1; + } + free(*argstr); + *argstr = nstr; + + return 0; +} + +static int inet4_pton(const char *src, uint16_t port, + struct sockaddr_storage *addr) +{ + struct sockaddr_in *addr4 = (struct sockaddr_in *)addr; + + if (strlen(src) > INET_ADDRSTRLEN) + return -EINVAL; + + if (inet_pton(AF_INET, src, &addr4->sin_addr.s_addr) <= 0) + return -EINVAL; + + addr4->sin_family = AF_INET; + addr4->sin_port = htons(port); + + return 0; +} + +static int inet6_pton(nvme_root_t r, const char *src, uint16_t port, + struct sockaddr_storage *addr) +{ + int ret = -EINVAL; + struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr; + + if (strlen(src) > INET6_ADDRSTRLEN) + return -EINVAL; + + char *tmp = strdup(src); + if (!tmp) + nvme_msg(r, LOG_ERR, "cannot copy: %s\n", src); + + const char *scope = NULL; + char *p = strchr(tmp, SCOPE_DELIMITER); + if (p) { + *p = '\0'; + scope = src + (p - tmp) + 1; + } + + if (inet_pton(AF_INET6, tmp, &addr6->sin6_addr) != 1) + goto free_tmp; + + if (IN6_IS_ADDR_LINKLOCAL(&addr6->sin6_addr) && scope) { + addr6->sin6_scope_id = if_nametoindex(scope); + if (addr6->sin6_scope_id == 0) { + nvme_msg(r, LOG_ERR, + "can't find iface index for: %s (%m)\n", scope); + goto free_tmp; + } + } + + addr6->sin6_family = AF_INET6; + addr6->sin6_port = htons(port); + ret = 0; + +free_tmp: + free(tmp); + return ret; +} + +/** + * inet_pton_with_scope - convert an IPv4/IPv6 to socket address + * @r: nvme_root_t object + * @af: address family, AF_INET, AF_INET6 or AF_UNSPEC for either + * @src: the start of the address string + * @trsvcid: transport service identifier + * @addr: output socket address + * + * Return 0 on success, errno otherwise. + */ +static int inet_pton_with_scope(nvme_root_t r, int af, + const char *src, const char * trsvcid, + struct sockaddr_storage *addr) +{ + int ret = -EINVAL; + uint16_t port = 0; + + if (trsvcid) { + unsigned long long tmp = strtoull(trsvcid, NULL, 0); + port = (uint16_t)tmp; + if (tmp != port) { + nvme_msg(r, LOG_ERR, "trsvcid out of range: %s\n", + trsvcid); + return -ERANGE; + } + } else { + port = 0; + } + + switch (af) { + case AF_INET: + ret = inet4_pton(src, port, addr); + break; + case AF_INET6: + ret = inet6_pton(r, src, port, addr); + break; + case AF_UNSPEC: + ret = inet4_pton(src, port, addr); + if (ret) + ret = inet6_pton(r, src, port, addr); + break; + default: + nvme_msg(r, LOG_ERR, "unexpected address family %d\n", af); + } + + return ret; +} + +static bool traddr_is_hostname(nvme_root_t r, nvme_ctrl_t c) +{ + struct sockaddr_storage addr; + + if (!c->traddr) + return false; + if (strcmp(c->transport, "tcp") && strcmp(c->transport, "rdma")) + return false; + if (inet_pton_with_scope(r, AF_UNSPEC, c->traddr, c->trsvcid, &addr) == 0) + return false; + return true; +} + +static int build_options(nvme_host_t h, nvme_ctrl_t c, char **argstr) +{ + struct nvme_fabrics_config *cfg = nvme_ctrl_get_config(c); + const char *transport = nvme_ctrl_get_transport(c); + const char *hostnqn, *hostid, *hostkey, *ctrlkey; + bool discover = false, discovery_nqn = false; + + if (!transport) { + nvme_msg(h->r, LOG_ERR, "need a transport (-t) argument\n"); + return -ENVME_CONNECT_TARG; + } + + if (strncmp(transport, "loop", 4)) { + if (!nvme_ctrl_get_traddr(c)) { + nvme_msg(h->r, LOG_ERR, "need a address (-a) argument\n"); + return -ENVME_CONNECT_AARG; + } + } + + /* always specify nqn as first arg - this will init the string */ + if (asprintf(argstr, "nqn=%s", + nvme_ctrl_get_subsysnqn(c)) < 0) { + return -ENOMEM; + } + if (!strcmp(nvme_ctrl_get_subsysnqn(c), NVME_DISC_SUBSYS_NAME)) { + nvme_ctrl_set_discovery_ctrl(c, true); + discovery_nqn = true; + } + if (nvme_ctrl_is_discovery_ctrl(c)) + discover = true; + hostnqn = nvme_host_get_hostnqn(h); + hostid = nvme_host_get_hostid(h); + hostkey = nvme_host_get_dhchap_key(h); + ctrlkey = nvme_ctrl_get_dhchap_key(c); + if (add_argument(argstr, "transport", transport) || + add_argument(argstr, "traddr", + nvme_ctrl_get_traddr(c)) || + add_argument(argstr, "host_traddr", + cfg->host_traddr) || + add_argument(argstr, "host_iface", + cfg->host_iface) || + add_argument(argstr, "trsvcid", + nvme_ctrl_get_trsvcid(c)) || + (hostnqn && add_argument(argstr, "hostnqn", hostnqn)) || + (hostid && add_argument(argstr, "hostid", hostid)) || + (discover && !discovery_nqn && + add_bool_argument(argstr, "discovery", true)) || + (!discover && hostkey && + add_argument(argstr, "dhchap_secret", hostkey)) || + (!discover && ctrlkey && + add_argument(argstr, "dhchap_ctrl_secret", ctrlkey)) || + (!discover && + add_int_argument(argstr, "nr_io_queues", + cfg->nr_io_queues, false)) || + (!discover && + add_int_argument(argstr, "nr_write_queues", + cfg->nr_write_queues, false)) || + (!discover && + add_int_argument(argstr, "nr_poll_queues", + cfg->nr_poll_queues, false)) || + (!discover && + add_int_argument(argstr, "queue_size", + cfg->queue_size, false)) || + add_int_argument(argstr, "keep_alive_tmo", + cfg->keep_alive_tmo, false) || + add_int_argument(argstr, "reconnect_delay", + cfg->reconnect_delay, false) || + (strcmp(transport, "loop") && + add_int_or_minus_one_argument(argstr, "ctrl_loss_tmo", + cfg->ctrl_loss_tmo)) || + (strcmp(transport, "loop") && + add_int_argument(argstr, "fast_io_fail_tmo", + cfg->fast_io_fail_tmo, false)) || + (strcmp(transport, "loop") && + add_int_argument(argstr, "tos", cfg->tos, true)) || + add_bool_argument(argstr, "duplicate_connect", + cfg->duplicate_connect) || + add_bool_argument(argstr, "disable_sqflow", + cfg->disable_sqflow) || + (!strcmp(transport, "tcp") && + add_bool_argument(argstr, "hdr_digest", cfg->hdr_digest)) || + (!strcmp(transport, "tcp") && + add_bool_argument(argstr, "data_digest", cfg->data_digest)) || + (!strcmp(transport, "tcp") && + add_bool_argument(argstr, "tls", cfg->tls))) { + free(*argstr); + return -1; + } + + return 0; +} + +static int __nvmf_add_ctrl(nvme_root_t r, const char *argstr) +{ + int ret, fd, len = strlen(argstr); + char buf[0x1000], *options, *p; + + fd = open(nvmf_dev, O_RDWR); + if (fd < 0) { + nvme_msg(r, LOG_ERR, "Failed to open %s: %s\n", + nvmf_dev, strerror(errno)); + return -ENVME_CONNECT_OPEN; + } + + nvme_msg(r, LOG_DEBUG, "connect ctrl, '%.*s'\n", + (int)strcspn(argstr,"\n"), argstr); + ret = write(fd, argstr, len); + if (ret != len) { + nvme_msg(r, LOG_ERR, "Failed to write to %s: %s\n", + nvmf_dev, strerror(errno)); + ret = -ENVME_CONNECT_WRITE; + goto out_close; + } + + len = read(fd, buf, sizeof(buf)); + if (len < 0) { + nvme_msg(r, LOG_ERR, "Failed to read from %s: %s\n", + nvmf_dev, strerror(errno)); + ret = -ENVME_CONNECT_READ; + goto out_close; + } + nvme_msg(r, LOG_DEBUG, "connect ctrl, response '%.*s'\n", + (int)strcspn(buf, "\n"), buf); + buf[len] = '\0'; + options = buf; + while ((p = strsep(&options, ",\n")) != NULL) { + if (!*p) + continue; + if (sscanf(p, "instance=%d", &ret) == 1) + goto out_close; + } + + nvme_msg(r, LOG_ERR, "Failed to parse ctrl info for \"%s\"\n", argstr); + ret = -ENVME_CONNECT_PARSE; +out_close: + close(fd); + return ret; +} + +int nvmf_add_ctrl(nvme_host_t h, nvme_ctrl_t c, + const struct nvme_fabrics_config *cfg) +{ + char *argstr; + int ret; + + cfg = merge_config(c, cfg); + nvme_ctrl_set_discovered(c, true); + if (traddr_is_hostname(h->r, c)) { + char *traddr = c->traddr; + + c->traddr = hostname2traddr(h->r, traddr); + if (!c->traddr) { + c->traddr = traddr; + errno = ENVME_CONNECT_TRADDR; + return -1; + } + free(traddr); + } + + ret = build_options(h, c, &argstr); + if (ret) + return ret; + + ret = __nvmf_add_ctrl(h->r, argstr); + free(argstr); + if (ret < 0) { + errno = -ret; + return -1; + } + + nvme_msg(h->r, LOG_INFO, "nvme%d: ctrl connected\n", ret); + return nvme_init_ctrl(h, c, ret); +} + +nvme_ctrl_t nvmf_connect_disc_entry(nvme_host_t h, + struct nvmf_disc_log_entry *e, + const struct nvme_fabrics_config *cfg, + bool *discover) +{ + const char *transport; + char *traddr = NULL, *trsvcid = NULL; + nvme_ctrl_t c; + int ret; + + switch (e->trtype) { + case NVMF_TRTYPE_RDMA: + case NVMF_TRTYPE_TCP: + switch (e->adrfam) { + case NVMF_ADDR_FAMILY_IP4: + case NVMF_ADDR_FAMILY_IP6: + strchomp(e->traddr, NVMF_TRADDR_SIZE - 1); + strchomp(e->trsvcid, NVMF_TRSVCID_SIZE - 1); + traddr = e->traddr; + trsvcid = e->trsvcid; + break; + default: + nvme_msg(h->r, LOG_ERR, + "skipping unsupported adrfam %d\n", + e->adrfam); + errno = EINVAL; + return NULL; + } + break; + case NVMF_TRTYPE_FC: + switch (e->adrfam) { + case NVMF_ADDR_FAMILY_FC: + strchomp(e->traddr, NVMF_TRADDR_SIZE - 1); + traddr = e->traddr; + break; + default: + nvme_msg(h->r, LOG_ERR, + "skipping unsupported adrfam %d\n", + e->adrfam); + errno = EINVAL; + return NULL; + } + break; + case NVMF_TRTYPE_LOOP: + strchomp(e->traddr, NVMF_TRADDR_SIZE - 1); + traddr = strlen(e->traddr) ? e->traddr : NULL; + break; + default: + nvme_msg(h->r, LOG_ERR, "skipping unsupported transport %d\n", + e->trtype); + errno = EINVAL; + return NULL; + } + + transport = nvmf_trtype_str(e->trtype); + + nvme_msg(h->r, LOG_DEBUG, "lookup ctrl " + "(transport: %s, traddr: %s, trsvcid %s)\n", + transport, traddr, trsvcid); + c = nvme_create_ctrl(h->r, e->subnqn, transport, traddr, + cfg->host_traddr, cfg->host_iface, trsvcid); + if (!c) { + nvme_msg(h->r, LOG_DEBUG, "skipping discovery entry, " + "failed to allocate %s controller with traddr %s\n", + transport, traddr); + errno = ENOMEM; + return NULL; + } + + switch (e->subtype) { + case NVME_NQN_CURR: + nvme_ctrl_set_discovered(c, true); + break; + case NVME_NQN_DISC: + if (discover) + *discover = true; + nvme_ctrl_set_discovery_ctrl(c, true); + break; + default: + nvme_msg(h->r, LOG_ERR, "unsupported subtype %d\n", + e->subtype); + /* fallthrough */ + case NVME_NQN_NVME: + nvme_ctrl_set_discovery_ctrl(c, false); + break; + } + + if (nvme_ctrl_is_discovered(c)) { + nvme_free_ctrl(c); + errno = EAGAIN; + return NULL; + } + + if (e->treq & NVMF_TREQ_DISABLE_SQFLOW) + c->cfg.disable_sqflow = true; + + if (e->trtype == NVMF_TRTYPE_TCP && + (e->treq & NVMF_TREQ_REQUIRED || + e->treq & NVMF_TREQ_NOT_REQUIRED)) + c->cfg.tls = true; + + ret = nvmf_add_ctrl(h, c, cfg); + if (!ret) + return c; + + if (errno == EINVAL && c->cfg.disable_sqflow) { + errno = 0; + /* disable_sqflow is unrecognized option on older kernels */ + nvme_msg(h->r, LOG_INFO, "failed to connect controller, " + "retry with disabling SQ flow control\n"); + c->cfg.disable_sqflow = false; + ret = nvmf_add_ctrl(h, c, cfg); + if (!ret) + return c; + } + nvme_msg(h->r, LOG_ERR, "failed to connect controller, error %d\n", + errno); + nvme_free_ctrl(c); + return NULL; +} + +static int nvme_discovery_log(int fd, __u32 len, struct nvmf_discovery_log *log, bool rae) +{ + struct nvme_get_log_args args = { + .args_size = sizeof(args), + .fd = fd, + .nsid = NVME_NSID_NONE, + .lsp = NVME_LOG_LSP_NONE, + .lsi = NVME_LOG_LSI_NONE, + .uuidx = NVME_UUID_NONE, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = NULL, + .lid = NVME_LOG_LID_DISCOVER, + .log = log, + .len = len, + .csi = NVME_CSI_NVM, + .rae = rae, + .ot = false, + }; + + return nvme_get_log_page(fd, 4096, &args); +} + +int nvmf_get_discovery_log(nvme_ctrl_t c, struct nvmf_discovery_log **logp, + int max_retries) +{ + nvme_root_t r = c->s && c->s->h ? c->s->h->r : NULL; + struct nvmf_discovery_log *log; + int hdr, ret, retries = 0; + const char *name = nvme_ctrl_get_name(c); + uint64_t genctr, numrec; + unsigned int size; + + hdr = sizeof(struct nvmf_discovery_log); + log = malloc(hdr); + if (!log) { + nvme_msg(r, LOG_ERR, + "could not allocate memory for discovery log header\n"); + errno = ENOMEM; + return -1; + } + memset(log, 0, hdr); + + nvme_msg(r, LOG_DEBUG, "%s: discover length %d\n", name, 0x100); + ret = nvme_discovery_log(nvme_ctrl_get_fd(c), 0x100, log, true); + if (ret) { + nvme_msg(r, LOG_INFO, "%s: discover failed, error %d\n", + name, errno); + goto out_free_log; + } + + do { + numrec = le64_to_cpu(log->numrec); + genctr = le64_to_cpu(log->genctr); + + if (numrec == 0) { + *logp = log; + return 0; + } + + size = sizeof(struct nvmf_discovery_log) + + sizeof(struct nvmf_disc_log_entry) * (numrec); + + free(log); + log = malloc(size); + if (!log) { + nvme_msg(r, LOG_ERR, + "could not alloc memory for discovery log page\n"); + errno = ENOMEM; + return -1; + } + memset(log, 0, size); + + nvme_msg(r, LOG_DEBUG, "%s: discover length %d\n", name, size); + ret = nvme_discovery_log(nvme_ctrl_get_fd(c), size, log, false); + if (ret) { + nvme_msg(r, LOG_INFO, + "%s: discover try %d/%d failed, error %d\n", + name, retries, max_retries, errno); + goto out_free_log; + } + + genctr = le64_to_cpu(log->genctr); + nvme_msg(r, LOG_DEBUG, + "%s: discover genctr %" PRIu64 ", retry\n", + name, genctr); + ret = nvme_discovery_log(nvme_ctrl_get_fd(c), hdr, log, true); + if (ret) { + nvme_msg(r, LOG_INFO, + "%s: discover try %d/%d failed, error %d\n", + name, retries, max_retries, errno); + goto out_free_log; + } + } while (genctr != le64_to_cpu(log->genctr) && + ++retries < max_retries); + + if (genctr != le64_to_cpu(log->genctr)) { + nvme_msg(r, LOG_INFO, "%s: discover genctr mismatch\n", name); + errno = EAGAIN; + ret = -1; + } else if (numrec != le64_to_cpu(log->numrec)) { + nvme_msg(r, LOG_INFO, + "%s: could only fetch %" PRIu64 " of %" PRIu64 " records\n", + name, numrec, le64_to_cpu(log->numrec)); + errno = EBADSLT; + ret = -1; + } else { + *logp = log; + return 0; + } + +out_free_log: + free(log); + return ret; +} + +#define PATH_UUID_IBM "/proc/device-tree/ibm,partition-uuid" + +static int uuid_from_device_tree(char *system_uuid) +{ + ssize_t len; + int f; + + f = open(PATH_UUID_IBM, O_RDONLY); + if (f < 0) + return -ENXIO; + + memset(system_uuid, 0, UUID_SIZE); + len = read(f, system_uuid, UUID_SIZE - 1); + close(f); + if (len < 0) + return -ENXIO; + + return strlen(system_uuid) ? 0 : -ENXIO; +} + +#define PATH_DMI_ENTRIES "/sys/firmware/dmi/entries" + +static int uuid_from_dmi_entries(char *system_uuid) +{ + int f; + DIR *d; + struct dirent *de; + char buf[512]; + + system_uuid[0] = '\0'; + d = opendir(PATH_DMI_ENTRIES); + if (!d) + return -ENXIO; + while ((de = readdir(d))) { + char filename[PATH_MAX]; + int len, type; + + if (de->d_name[0] == '.') + continue; + sprintf(filename, "%s/%s/type", PATH_DMI_ENTRIES, de->d_name); + f = open(filename, O_RDONLY); + if (f < 0) + continue; + len = read(f, buf, 512); + close(f); + if (len < 0) + continue; + if (sscanf(buf, "%d", &type) != 1) + continue; + if (type != 1) + continue; + sprintf(filename, "%s/%s/raw", PATH_DMI_ENTRIES, de->d_name); + f = open(filename, O_RDONLY); + if (f < 0) + continue; + len = read(f, buf, 512); + close(f); + if (len < 0) + continue; + /* Sigh. https://en.wikipedia.org/wiki/Overengineering */ + /* DMTF SMBIOS 3.0 Section 7.2.1 System UUID */ + sprintf(system_uuid, + "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-" + "%02x%02x%02x%02x%02x%02x", + (uint8_t)buf[8 + 3], (uint8_t)buf[8 + 2], + (uint8_t)buf[8 + 1], (uint8_t)buf[8 + 0], + (uint8_t)buf[8 + 5], (uint8_t)buf[8 + 4], + (uint8_t)buf[8 + 7], (uint8_t)buf[8 + 6], + (uint8_t)buf[8 + 8], (uint8_t)buf[8 + 9], + (uint8_t)buf[8 + 10], (uint8_t)buf[8 + 11], + (uint8_t)buf[8 + 12], (uint8_t)buf[8 + 13], + (uint8_t)buf[8 + 14], (uint8_t)buf[8 + 15]); + break; + } + closedir(d); + return strlen(system_uuid) ? 0 : -ENXIO; +} + +#define PATH_DMI_PROD_UUID "/sys/class/dmi/id/product_uuid" + +/** + * uuid_from_product_uuid() - Get system UUID from product_uuid + * @system_uuid: Where to save the system UUID. + * + * Return: 0 on success, -ENXIO otherwise. + */ +static int uuid_from_product_uuid(char *system_uuid) +{ + FILE *stream; + ssize_t nread; + int ret; + char *line = NULL; + size_t len = 0; + + stream = fopen(PATH_DMI_PROD_UUID, "re"); + if (!stream) + return -ENXIO; + system_uuid[0] = '\0'; + + nread = getline(&line, &len, stream); + if (nread != UUID_SIZE) { + ret = -ENXIO; + goto out; + } + + /* The kernel is handling the byte swapping according DMTF + * SMBIOS 3.0 Section 7.2.1 System UUID */ + + memcpy(system_uuid, line, UUID_SIZE - 1); + system_uuid[UUID_SIZE - 1] = '\0'; + + ret = 0; + +out: + free(line); + fclose(stream); + + return ret; +} + +/** + * uuid_from_dmi() - read system UUID + * @system_uuid: buffer for the UUID + * + * The system UUID can be read from two different locations: + * + * 1) /sys/class/dmi/id/product_uuid + * 2) /sys/firmware/dmi/entries + * + * Note that the second location is not present on Debian-based systems. + * + * Return: 0 on success, negative errno otherwise. + */ +static int uuid_from_dmi(char *system_uuid) +{ + int ret = uuid_from_product_uuid(system_uuid); + if (ret != 0) + ret = uuid_from_dmi_entries(system_uuid); + return ret; +} + +char *nvmf_hostnqn_generate() +{ + char *hostnqn; + int ret; + char uuid_str[UUID_SIZE]; + uuid_t uuid; + + ret = uuid_from_dmi(uuid_str); + if (ret < 0) { + ret = uuid_from_device_tree(uuid_str); + } + if (ret < 0) { + uuid_generate_random(uuid); + uuid_unparse_lower(uuid, uuid_str); + } + + if (asprintf(&hostnqn, "nqn.2014-08.org.nvmexpress:uuid:%s", uuid_str) < 0) + return NULL; + + return hostnqn; +} + +static char *nvmf_read_file(const char *f, int len) +{ + char buf[len]; + int ret, fd; + + fd = open(f, O_RDONLY); + if (fd < 0) + return NULL; + + memset(buf, 0, len); + ret = read(fd, buf, len - 1); + close (fd); + + if (ret < 0 || !strlen(buf)) + return NULL; + return strndup(buf, strcspn(buf, "\n")); +} + +char *nvmf_hostnqn_from_file() +{ + return nvmf_read_file(NVMF_HOSTNQN_FILE, NVMF_NQN_SIZE); +} + +char *nvmf_hostid_from_file() +{ + return nvmf_read_file(NVMF_HOSTID_FILE, NVMF_HOSTID_SIZE); +} + +/** + * nvmf_get_tel() - Calculate the amount of memory needed for a DIE. + * @hostsymname: Symbolic name (may be NULL) + * + * Each Discovery Information Entry (DIE) must contain at a minimum an + * Extended Attribute for the HostID. The Entry may optionally contain an + * Extended Attribute for the Symbolic Name. + * + * Return: Total Entry Length + */ +static __u32 nvmf_get_tel(const char *hostsymname) +{ + __u32 tel = sizeof(struct nvmf_ext_die); + __u16 len; + + /* Host ID is mandatory */ + tel += nvmf_exat_size(sizeof(uuid_t)); + + /* Symbolic name is optional */ + len = hostsymname ? strlen(hostsymname) : 0; + if (len) + tel += nvmf_exat_size(len); + + return tel; +} + +/** + * nvmf_fill_die() - Fill a Discovery Information Entry. + * @die: Pointer to Discovery Information Entry to be filled + * @h: Pointer to the host data structure + * @tel: Length of the DIE + * @trtype: Transport type + * @adrfam: Address family + * @reg_addr: Address to register. Setting this to an empty string tells + * the DC to infer address from the source address of the socket. + * @tsas: Transport Specific Address Subtype for the address being + * registered. + */ +static void nvmf_fill_die(struct nvmf_ext_die *die, struct nvme_host *h, + __u32 tel, __u8 trtype, __u8 adrfam, + const char *reg_addr, union nvmf_tsas *tsas) +{ + __u16 numexat = 0; + size_t symname_len; + struct nvmf_ext_attr *exat; + + die->tel = cpu_to_le32(tel); + die->trtype = trtype; + die->adrfam = adrfam; + + memcpy(die->nqn, h->hostnqn, MIN(sizeof(die->nqn), strlen(h->hostnqn))); + memcpy(die->traddr, reg_addr, MIN(sizeof(die->traddr), strlen(reg_addr))); + + if (tsas) + memcpy(&die->tsas, tsas, sizeof(die->tsas)); + + /* Extended Attribute for the HostID (mandatory) */ + numexat++; + exat = die->exat; + exat->exattype = cpu_to_le16(NVMF_EXATTYPE_HOSTID); + exat->exatlen = cpu_to_le16(nvmf_exat_len(sizeof(uuid_t))); + uuid_parse(h->hostid, exat->exatval); + + /* Extended Attribute for the Symbolic Name (optional) */ + symname_len = h->hostsymname ? strlen(h->hostsymname) : 0; + if (symname_len) { + __u16 exatlen = nvmf_exat_len(symname_len); + + numexat++; + exat = nvmf_exat_ptr_next(exat); + exat->exattype = cpu_to_le16(NVMF_EXATTYPE_SYMNAME); + exat->exatlen = cpu_to_le16(exatlen); + memcpy(exat->exatval, h->hostsymname, symname_len); + /* Per Base specs, ASCII strings must be padded with spaces */ + memset(&exat->exatval[symname_len], ' ', exatlen - symname_len); + } + + die->numexat = cpu_to_le16(numexat); +} + +/** + * nvmf_dim() - Explicit reg, dereg, reg-update issuing DIM + * @c: Host NVMe controller instance maintaining the admin queue used to + * submit the DIM command to the DC. + * @tas: Task field of the Command Dword 10 (cdw10). Indicates whether to + * perform a Registration, Deregistration, or Registration-update. + * @trtype: Transport type (&enum nvmf_trtype - must be NVMF_TRTYPE_TCP) + * @adrfam: Address family (&enum nvmf_addr_family) + * @reg_addr: Address to register. Setting this to an empty string tells + * the DC to infer address from the source address of the socket. + * @tsas: Transport Specific Address Subtype for the address being + * registered. + * @result: Location where to save the command-specific result returned by + * the discovery controller. + * + * Perform explicit registration, deregistration, or + * registration-update (specified by @tas) by sending a Discovery + * Information Management (DIM) command to the Discovery Controller + * (DC). + * + * Return: 0 on success; on failure -1 is returned and errno is set + */ +static int nvmf_dim(nvme_ctrl_t c, enum nvmf_dim_tas tas, __u8 trtype, + __u8 adrfam, const char *reg_addr, union nvmf_tsas *tsas, + __u32 *result) +{ + nvme_root_t r = c->s && c->s->h ? c->s->h->r : NULL; + struct nvmf_dim_data *dim; + struct nvmf_ext_die *die; + __u32 tdl; + __u32 tel; + int ret; + + struct nvme_dim_args args = { + .args_size = sizeof(args), + .fd = nvme_ctrl_get_fd(c), + .result = result, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .tas = tas + }; + + if (!c->s) { + nvme_msg(r, LOG_ERR, + "%s: failed to perform DIM. subsystem undefined.\n", + c->name); + errno = EINVAL; + return -1; + } + + if (!c->s->h) { + nvme_msg(r, LOG_ERR, + "%s: failed to perform DIM. host undefined.\n", + c->name); + errno = EINVAL; + return -1; + } + + if (!c->s->h->hostid) { + nvme_msg(r, LOG_ERR, + "%s: failed to perform DIM. hostid undefined.\n", + c->name); + errno = EINVAL; + return -1; + } + + if (!c->s->h->hostnqn) { + nvme_msg(r, LOG_ERR, + "%s: failed to perform DIM. hostnqn undefined.\n", + c->name); + errno = EINVAL; + return -1; + } + + if (strcmp(c->transport, "tcp")) { + nvme_msg(r, LOG_ERR, + "%s: DIM only supported for TCP connections.\n", + c->name); + errno = EINVAL; + return -1; + } + + /* Register one Discovery Information Entry (DIE) of size TEL */ + tel = nvmf_get_tel(c->s->h->hostsymname); + tdl = sizeof(struct nvmf_dim_data) + tel; + + dim = (struct nvmf_dim_data *)calloc(1, tdl); + if (!dim) { + errno = ENOMEM; + return -1; + } + + dim->tdl = cpu_to_le32(tdl); + dim->nument = cpu_to_le64(1); /* only one DIE to register */ + dim->entfmt = cpu_to_le16(NVMF_DIM_ENTFMT_EXTENDED); + dim->etype = cpu_to_le16(NVMF_DIM_ETYPE_HOST); + dim->ektype = cpu_to_le16(0x5F); /* must be 0x5F per specs */ + + memcpy(dim->eid, c->s->h->hostnqn, + MIN(sizeof(dim->eid), strlen(c->s->h->hostnqn))); + + ret = get_entity_name(dim->ename, sizeof(dim->ename)); + if (ret <= 0) + nvme_msg(r, LOG_INFO, "%s: Failed to retrieve ENAME. %s.\n", + c->name, strerror(errno)); + + ret = get_entity_version(dim->ever, sizeof(dim->ever)); + if (ret <= 0) + nvme_msg(r, LOG_INFO, "%s: Failed to retrieve EVER.\n", c->name); + + die = &dim->die->extended; + nvmf_fill_die(die, c->s->h, tel, trtype, adrfam, reg_addr, tsas); + + args.data_len = tdl; + args.data = dim; + ret = nvme_dim_send(&args); + + free(dim); + + return ret; +} + +/** + * nvme_get_adrfam() - Get address family for the address we're registering + * with the DC. + * + * We retrieve this info from the socket itself. If we can't get the source + * address from the socket, then we'll infer the address family from the + * address of the DC since the DC address has the same address family. + * + * @ctrl: Host NVMe controller instance maintaining the admin queue used to + * submit the DIM command to the DC. + * + * Return: The address family of the source address associated with the + * socket connected to the DC. + */ +static __u8 nvme_get_adrfam(nvme_ctrl_t c) +{ + struct sockaddr_storage addr; + __u8 adrfam = NVMF_ADDR_FAMILY_IP4; + nvme_root_t r = c->s && c->s->h ? c->s->h->r : NULL; + + if (!inet_pton_with_scope(r, AF_UNSPEC, c->traddr, c->trsvcid, &addr)) { + if (addr.ss_family == AF_INET6) + adrfam = NVMF_ADDR_FAMILY_IP6; + } + + return adrfam; +} + +/* These string definitions must match with the kernel */ +static const char *cntrltype_str[] = { + [NVME_CTRL_CNTRLTYPE_IO] = "io", + [NVME_CTRL_CNTRLTYPE_DISCOVERY] = "discovery", + [NVME_CTRL_CNTRLTYPE_ADMIN] = "admin", +}; + +static const char *dctype_str[] = { + [NVME_CTRL_DCTYPE_NOT_REPORTED] = "none", + [NVME_CTRL_DCTYPE_DDC] = "ddc", + [NVME_CTRL_DCTYPE_CDC] = "cdc", +}; + +/** + * nvme_fetch_cntrltype_dctype_from_id - Get cntrltype and dctype from identify command + * @c: Controller instance + * + * On legacy kernels the cntrltype and dctype are not exposed through the + * sysfs. We must get them directly from the controller by performing an + * identify command. + */ +static void nvme_fetch_cntrltype_dctype_from_id(nvme_ctrl_t c) +{ + struct nvme_id_ctrl id = { 0 }; + + if (nvme_ctrl_identify(c, &id)) + return; + + if (!c->cntrltype) { + if (id.cntrltype > NVME_CTRL_CNTRLTYPE_ADMIN || !cntrltype_str[id.cntrltype]) + c->cntrltype = strdup("reserved"); + else + c->cntrltype = strdup(cntrltype_str[id.cntrltype]); + } + + if (!c->dctype) { + if (id.dctype > NVME_CTRL_DCTYPE_CDC || !dctype_str[id.dctype]) + c->dctype = strdup("reserved"); + else + c->dctype = strdup(dctype_str[id.dctype]); + } +} + +bool nvmf_is_registration_supported(nvme_ctrl_t c) +{ + if (!c->cntrltype || !c->dctype) + nvme_fetch_cntrltype_dctype_from_id(c); + + return !strcmp(c->dctype, "ddc") || !strcmp(c->dctype, "cdc"); +} + +int nvmf_register_ctrl(nvme_ctrl_t c, enum nvmf_dim_tas tas, __u32 *result) +{ + if (!nvmf_is_registration_supported(c)) { + errno = ENOTSUP; + return -1; + } + + /* We're registering our source address with the DC. To do + * that, we can simply send an empty string. This tells the DC + * to retrieve the source address from the socket and use that + * as the registration address. + */ + return nvmf_dim(c, tas, NVMF_TRTYPE_TCP, nvme_get_adrfam(c), "", NULL, result); +} diff --git a/src/nvme/fabrics.h b/src/nvme/fabrics.h new file mode 100644 index 0000000..7f8a373 --- /dev/null +++ b/src/nvme/fabrics.h @@ -0,0 +1,273 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/* + * This file is part of libnvme. + * Copyright (c) 2020 Western Digital Corporation or its affiliates. + * + * Authors: Keith Busch <keith.busch@wdc.com> + * Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com> + */ +#ifndef _LIBNVME_FABRICS_H +#define _LIBNVME_FABRICS_H + +#include <stdbool.h> +#include <stdint.h> +#include "tree.h" + +/** + * DOC: fabrics.h + * + * Fabrics-specific definitions. + */ + +/* default to 600 seconds of reconnect attempts before giving up */ +#define NVMF_DEF_CTRL_LOSS_TMO 600 + +/** + * struct nvme_fabrics_config - Defines all linux nvme fabrics initiator options + * @host_traddr: Host transport address + * @host_iface: Host interface name + * @queue_size: Number of IO queue entries + * @nr_io_queues: Number of controller IO queues to establish + * @reconnect_delay: Time between two consecutive reconnect attempts. + * @ctrl_loss_tmo: Override the default controller reconnect attempt timeout in seconds + * @fast_io_fail_tmo: Set the fast I/O fail timeout in seconds. + * @keep_alive_tmo: Override the default keep-alive-timeout to this value in seconds + * @nr_write_queues: Number of queues to use for exclusively for writing + * @nr_poll_queues: Number of queues to reserve for polling completions + * @tos: Type of service + * @duplicate_connect: Allow multiple connections to the same target + * @disable_sqflow: Disable controller sq flow control + * @hdr_digest: Generate/verify header digest (TCP) + * @data_digest: Generate/verify data digest (TCP) + * @tls: Start TLS on the connection (TCP) + */ +struct nvme_fabrics_config { + char *host_traddr; + char *host_iface; + int queue_size; + int nr_io_queues; + int reconnect_delay; + int ctrl_loss_tmo; + int fast_io_fail_tmo; + int keep_alive_tmo; + int nr_write_queues; + int nr_poll_queues; + int tos; + + bool duplicate_connect; + bool disable_sqflow; + bool hdr_digest; + bool data_digest; + bool tls; +}; + +/** + * nvmf_trtype_str() - Decode TRTYPE field + * @trtype: value to be decoded + * + * Decode the transport type field in the discovery + * log page entry. + * + * Return: decoded string + */ +const char *nvmf_trtype_str(__u8 trtype); + +/** + * nvmf_adrfam_str() - Decode ADRFAM field + * @adrfam: value to be decoded + * + * Decode the address family field in the discovery + * log page entry. + * + * Return: decoded string + */ +const char *nvmf_adrfam_str(__u8 adrfam); + +/** + * nvmf_subtype_str() - Decode SUBTYPE field + * @subtype: value to be decoded + * + * Decode the subsystem type field in the discovery + * log page entry. + * + * Return: decoded string + */ +const char *nvmf_subtype_str(__u8 subtype); + +/** + * nvmf_treq_str() - Decode TREQ field + * @treq: value to be decoded + * + * Decode the transport requirements field in the + * discovery log page entry. + * + * Return: decoded string + */ +const char *nvmf_treq_str(__u8 treq); + +/** + * nvmf_eflags_str() - Decode EFLAGS field + * @eflags: value to be decoded + * + * Decode the EFLAGS field in the discovery log page + * entry. + * + * Return: decoded string + */ +const char *nvmf_eflags_str(__u16 eflags); + +/** + * nvmf_sectype_str() - Decode SECTYPE field + * @sectype: value to be decoded + * + * Decode the SECTYPE field in the discovery log page + * entry. + * + * Return: decoded string + */ +const char *nvmf_sectype_str(__u8 sectype); + +/** + * nvmf_prtype_str() - Decode RDMA Provider type field + * @prtype: value to be decoded + * + * Decode the RDMA Provider type field in the discovery + * log page entry. + * + * Return: decoded string + */ +const char *nvmf_prtype_str(__u8 prtype); + +/** + * nvmf_qptype_str() - Decode RDMA QP Service type field + * @qptype: value to be decoded + * + * Decode the RDMA QP Service type field in the discovery log page + * entry. + * + * Return: decoded string + */ +const char *nvmf_qptype_str(__u8 qptype); + +/** + * nvmf_cms_str() - Decode RDMA connection management service field + * @cms: value to be decoded + * + * Decode the RDMA connection management service field in the discovery + * log page entry. + * + * Return: decoded string + */ +const char *nvmf_cms_str(__u8 cms); + +/** + * nvmf_default_config() - Default values for fabrics configuration + * @cfg: config values to set + * + * Initializes @cfg with default values. + */ +void nvmf_default_config(struct nvme_fabrics_config *cfg); + +/** + * nvmf_update_config() - Update fabrics configuration values + * @c: Controller to be modified + * @cfg: Updated configuration values + * + * Updates the values from @c with the configuration values from @cfg; + * all non-default values from @cfg will overwrite the values in @c. + */ +void nvmf_update_config(nvme_ctrl_t c, const struct nvme_fabrics_config *cfg); + +/** + * nvmf_add_ctrl() - Connect a controller and update topology + * @h: Host to which the controller should be attached + * @c: Controller to be connected + * @cfg: Default configuration for the controller + * + * Issues a 'connect' command to the NVMe-oF controller and inserts @c + * into the topology using @h as parent. + * @c must be initialized and not connected to the topology. + * + * Return: 0 on success; on failure errno is set and -1 is returned. + */ +int nvmf_add_ctrl(nvme_host_t h, nvme_ctrl_t c, + const struct nvme_fabrics_config *cfg); + +/** + * nvmf_get_discovery_log() - Return the discovery log page + * @c: Discover controller to use + * @logp: Pointer to the log page to be returned + * @max_retries: maximum number of log page entries to be returned + * + * Return: 0 on success; on failure -1 is returned and errno is set + */ +int nvmf_get_discovery_log(nvme_ctrl_t c, struct nvmf_discovery_log **logp, + int max_retries); + +/** + * nvmf_hostnqn_generate() - Generate a machine specific host nqn + * Returns: An nvm namespace qualified name string based on the machine + * identifier, or NULL if not successful. + */ +char *nvmf_hostnqn_generate(); + +/** + * nvmf_hostnqn_from_file() - Reads the host nvm qualified name from the config + * default location in @SYSCONFDIR@/nvme/ + * Return: The host nqn, or NULL if unsuccessful. If found, the caller + * is responsible to free the string. + */ +char *nvmf_hostnqn_from_file(); + +/** + * nvmf_hostid_from_file() - Reads the host identifier from the config default + * location in @SYSCONFDIR@/nvme/. + * Return: The host identifier, or NULL if unsuccessful. If found, the caller + * is responsible to free the string. + */ +char *nvmf_hostid_from_file(); + +/** + * nvmf_connect_disc_entry() - Connect controller based on the discovery log page entry + * @h: Host to which the controller should be connected + * @e: Discovery log page entry + * @defcfg: Default configurationn to be used for the new controller + * @discover: Set to 'true' if the new controller is a discovery controller + * + * Return: Pointer to the new controller + */ +nvme_ctrl_t nvmf_connect_disc_entry(nvme_host_t h, + struct nvmf_disc_log_entry *e, + const struct nvme_fabrics_config *defcfg, bool *discover); + +/** + * nvmf_is_registration_supported - check whether registration can be performed. + * @c: Controller instance + * + * Only discovery controllers (DC) that comply with TP8010 support + * explicit registration with the DIM PDU. These can be identified by + * looking at the value of a dctype in the Identify command + * response. A value of 1 (DDC) or 2 (CDC) indicates that the DC + * supports explicit registration. + * + * Return: true if controller supports explicit registration. false + * otherwise. + */ +bool nvmf_is_registration_supported(nvme_ctrl_t c); + +/** + * nvmf_register_ctrl() - Perform registration task with a DC + * @c: Controller instance + * @tas: Task field of the Command Dword 10 (cdw10). Indicates whether to + * perform a Registration, Deregistration, or Registration-update. + * @result: The command-specific result returned by the DC upon command + * completion. + * + * Perform registration task with a Discovery Controller (DC). Three + * tasks are supported: register, deregister, and registration update. + * + * Return: 0 on success; on failure -1 is returned and errno is set + */ +int nvmf_register_ctrl(nvme_ctrl_t c, enum nvmf_dim_tas tas, __u32 *result); + +#endif /* _LIBNVME_FABRICS_H */ diff --git a/src/nvme/filters.c b/src/nvme/filters.c new file mode 100644 index 0000000..b5959a8 --- /dev/null +++ b/src/nvme/filters.c @@ -0,0 +1,118 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/* + * This file is part of libnvme. + * Copyright (c) 2020 Western Digital Corporation or its affiliates. + * + * Authors: Keith Busch <keith.busch@wdc.com> + * Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com> + */ +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <dirent.h> +#include <libgen.h> + +#include <sys/param.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <fcntl.h> +#include <unistd.h> + +#include "filters.h" +#include "types.h" +#include "util.h" + +const char *nvme_ctrl_sysfs_dir = "/sys/class/nvme"; +const char *nvme_ns_sysfs_dir = "/sys/block"; +const char *nvme_subsys_sysfs_dir = "/sys/class/nvme-subsystem"; + +int nvme_namespace_filter(const struct dirent *d) +{ + int i, n; + + if (d->d_name[0] == '.') + return 0; + + if (strstr(d->d_name, "nvme")) + if (sscanf(d->d_name, "nvme%dn%d", &i, &n) == 2) + return 1; + + return 0; +} + +int nvme_paths_filter(const struct dirent *d) +{ + int i, c, n; + + if (d->d_name[0] == '.') + return 0; + + if (strstr(d->d_name, "nvme")) + if (sscanf(d->d_name, "nvme%dc%dn%d", &i, &c, &n) == 3) + return 1; + + return 0; +} + +int nvme_ctrls_filter(const struct dirent *d) +{ + int i, c, n; + + if (d->d_name[0] == '.') + return 0; + + if (strstr(d->d_name, "nvme")) { + if (sscanf(d->d_name, "nvme%dc%dn%d", &i, &c, &n) == 3) + return 0; + if (sscanf(d->d_name, "nvme%dn%d", &i, &n) == 2) + return 0; + if (sscanf(d->d_name, "nvme%d", &i) == 1) + return 1; + } + + return 0; +} + +int nvme_subsys_filter(const struct dirent *d) +{ + int i; + + if (d->d_name[0] == '.') + return 0; + + if (strstr(d->d_name, "nvme-subsys")) + if (sscanf(d->d_name, "nvme-subsys%d", &i) == 1) + return 1; + + return 0; +} + +int nvme_scan_subsystems(struct dirent ***subsys) +{ + return scandir(nvme_subsys_sysfs_dir, subsys, nvme_subsys_filter, + alphasort); +} + +int nvme_scan_subsystem_namespaces(nvme_subsystem_t s, struct dirent ***ns) +{ + return scandir(nvme_subsystem_get_sysfs_dir(s), ns, + nvme_namespace_filter, alphasort); +} + +int nvme_scan_ctrls(struct dirent ***ctrls) +{ + return scandir(nvme_ctrl_sysfs_dir, ctrls, nvme_ctrls_filter, + alphasort); +} + +int nvme_scan_ctrl_namespace_paths(nvme_ctrl_t c, struct dirent ***paths) +{ + return scandir(nvme_ctrl_get_sysfs_dir(c), paths, + nvme_paths_filter, alphasort); +} + +int nvme_scan_ctrl_namespaces(nvme_ctrl_t c, struct dirent ***ns) +{ + return scandir(nvme_ctrl_get_sysfs_dir(c), ns, + nvme_namespace_filter, alphasort); +} diff --git a/src/nvme/filters.h b/src/nvme/filters.h new file mode 100644 index 0000000..49bbeea --- /dev/null +++ b/src/nvme/filters.h @@ -0,0 +1,96 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/* + * This file is part of libnvme. + * Copyright (c) 2020 Western Digital Corporation or its affiliates. + * + * Authors: Keith Busch <keith.busch@wdc.com> + */ + +#ifndef _LIBNVME_FILTERS_H +#define _LIBNVME_FILTERS_H + +#include <dirent.h> +#include "tree.h" + +/** + * DOC: filters.h + * + * libnvme directory filter + */ + +/** + * nvme_namespace_filter() - Filter for namespaces + * @d: dirent to check + * + * Return: 1 if @d matches, 0 otherwise + */ +int nvme_namespace_filter(const struct dirent *d); + +/** + * nvme_paths_filter() - Filter for paths + * @d: dirent to check + * + * Return: 1 if @d matches, 0 otherwise + */ +int nvme_paths_filter(const struct dirent *d); + +/** + * nvme_ctrls_filter() - Filter for controllers + * @d: dirent to check + * + * Return: 1 if @d matches, 0 otherwise + */ +int nvme_ctrls_filter(const struct dirent *d); + +/** + * nvme_subsys_filter() - Filter for subsystems + * @d: dirent to check + * + * Return: 1 if @d matches, 0 otherwise + */ +int nvme_subsys_filter(const struct dirent *d); + +/** + * nvme_scan_subsystems() - Scan for subsystems + * @subsys: Pointer to array of dirents + * + * Return: number of entries in @subsys + */ +int nvme_scan_subsystems(struct dirent ***subsys); + +/** + * nvme_scan_subsystem_namespaces() - Scan for namespaces in a subsystem + * @s: Subsystem to scan + * @ns: Pointer to array of dirents + * + * Return: number of entries in @ns + */ +int nvme_scan_subsystem_namespaces(nvme_subsystem_t s, struct dirent ***ns); + +/** + * nvme_scan_ctrls() - Scan for controllers + * @ctrls: Pointer to array of dirents + * + * Return: number of entries in @ctrls + */ +int nvme_scan_ctrls(struct dirent ***ctrls); + +/** + * nvme_scan_ctrl_namespace_paths() - Scan for namespace paths in a controller + * @c: Controller to scan + * @paths: Pointer to array of dirents + * + * Return: number of entries in @paths + */ +int nvme_scan_ctrl_namespace_paths(nvme_ctrl_t c, struct dirent ***paths); + +/** + * nvme_scan_ctrl_namespaces() - Scan for namespaces in a controller + * @c: Controller to scan + * @ns: Pointer to array of dirents + * + * Return: number of entries in @ns + */ +int nvme_scan_ctrl_namespaces(nvme_ctrl_t c, struct dirent ***ns); + +#endif /* _LIBNVME_FILTERS_H */ diff --git a/src/nvme/ioctl.c b/src/nvme/ioctl.c new file mode 100644 index 0000000..f48b465 --- /dev/null +++ b/src/nvme/ioctl.c @@ -0,0 +1,1870 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/* + * This file is part of libnvme. + * Copyright (c) 2020 Western Digital Corporation or its affiliates. + * + * Authors: Keith Busch <keith.busch@wdc.com> + * Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com> + */ +#include <errno.h> +#include <fcntl.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include <sys/ioctl.h> +#include <sys/stat.h> + +#include <ccan/build_assert/build_assert.h> +#include <ccan/endian/endian.h> + +#include "ioctl.h" +#include "util.h" + +static int nvme_verify_chr(int fd) +{ + static struct stat nvme_stat; + int err = fstat(fd, &nvme_stat); + + if (err < 0) + return errno; + + if (!S_ISCHR(nvme_stat.st_mode)) { + errno = ENOTBLK; + return -1; + } + return 0; +} + +int nvme_subsystem_reset(int fd) +{ + int ret; + + ret = nvme_verify_chr(fd); + if (ret) + return ret; + return ioctl(fd, NVME_IOCTL_SUBSYS_RESET); +} + +int nvme_ctrl_reset(int fd) +{ + int ret; + + ret = nvme_verify_chr(fd); + if (ret) + return ret; + return ioctl(fd, NVME_IOCTL_RESET); +} + +int nvme_ns_rescan(int fd) +{ + int ret; + + ret = nvme_verify_chr(fd); + if (ret) + return ret; + return ioctl(fd, NVME_IOCTL_RESCAN); +} + +int nvme_get_nsid(int fd, __u32 *nsid) +{ + errno = 0; + *nsid = ioctl(fd, NVME_IOCTL_ID); + return -1 * (errno != 0); +} + +static int nvme_submit_passthru64(int fd, unsigned long ioctl_cmd, + struct nvme_passthru_cmd64 *cmd, + __u64 *result) +{ + int err = ioctl(fd, ioctl_cmd, cmd); + + if (err >= 0 && result) + *result = cmd->result; + return err; +} + +static int nvme_submit_passthru(int fd, unsigned long ioctl_cmd, + struct nvme_passthru_cmd *cmd, __u32 *result) +{ + int err = ioctl(fd, ioctl_cmd, cmd); + + if (err >= 0 && result) + *result = cmd->result; + return err; +} + +static int nvme_passthru64(int fd, unsigned long ioctl_cmd, __u8 opcode, + __u8 flags, __u16 rsvd, __u32 nsid, __u32 cdw2, + __u32 cdw3, __u32 cdw10, __u32 cdw11, __u32 cdw12, + __u32 cdw13, __u32 cdw14, __u32 cdw15, + __u32 data_len, void *data, __u32 metadata_len, + void *metadata, __u32 timeout_ms, __u64 *result) +{ + struct nvme_passthru_cmd64 cmd = { + .opcode = opcode, + .flags = flags, + .rsvd1 = rsvd, + .nsid = nsid, + .cdw2 = cdw2, + .cdw3 = cdw3, + .metadata = (__u64)(uintptr_t)metadata, + .addr = (__u64)(uintptr_t)data, + .metadata_len = metadata_len, + .data_len = data_len, + .cdw10 = cdw10, + .cdw11 = cdw11, + .cdw12 = cdw12, + .cdw13 = cdw13, + .cdw14 = cdw14, + .cdw15 = cdw15, + .timeout_ms = timeout_ms, + }; + + return nvme_submit_passthru64(fd, ioctl_cmd, &cmd, result); +} + +static int nvme_passthru(int fd, unsigned long ioctl_cmd, __u8 opcode, + __u8 flags, __u16 rsvd, __u32 nsid, __u32 cdw2, + __u32 cdw3, __u32 cdw10, __u32 cdw11, __u32 cdw12, + __u32 cdw13, __u32 cdw14, __u32 cdw15, __u32 data_len, + void *data, __u32 metadata_len, void *metadata, + __u32 timeout_ms, __u32 *result) +{ + struct nvme_passthru_cmd cmd = { + .opcode = opcode, + .flags = flags, + .rsvd1 = rsvd, + .nsid = nsid, + .cdw2 = cdw2, + .cdw3 = cdw3, + .metadata = (__u64)(uintptr_t)metadata, + .addr = (__u64)(uintptr_t)data, + .metadata_len = metadata_len, + .data_len = data_len, + .cdw10 = cdw10, + .cdw11 = cdw11, + .cdw12 = cdw12, + .cdw13 = cdw13, + .cdw14 = cdw14, + .cdw15 = cdw15, + .timeout_ms = timeout_ms, + }; + + return nvme_submit_passthru(fd, ioctl_cmd, &cmd, result); +} + +int nvme_submit_admin_passthru64(int fd, struct nvme_passthru_cmd64 *cmd, + __u64 *result) +{ + return nvme_submit_passthru64(fd, NVME_IOCTL_ADMIN64_CMD, cmd, result); +} + +int nvme_admin_passthru64(int fd, __u8 opcode, __u8 flags, __u16 rsvd, + __u32 nsid, __u32 cdw2, __u32 cdw3, __u32 cdw10, + __u32 cdw11, __u32 cdw12, __u32 cdw13, __u32 cdw14, + __u32 cdw15, __u32 data_len, void *data, + __u32 metadata_len, void *metadata, __u32 timeout_ms, + __u64 *result) +{ + return nvme_passthru64(fd, NVME_IOCTL_ADMIN64_CMD, opcode, flags, rsvd, + nsid, cdw2, cdw3, cdw10, cdw11, cdw12, cdw13, + cdw14, cdw15, data_len, data, metadata_len, + metadata, timeout_ms, result); +} + +int nvme_submit_admin_passthru(int fd, struct nvme_passthru_cmd *cmd, __u32 *result) +{ + return nvme_submit_passthru(fd, NVME_IOCTL_ADMIN_CMD, cmd, result); +} + +int nvme_admin_passthru(int fd, __u8 opcode, __u8 flags, __u16 rsvd, + __u32 nsid, __u32 cdw2, __u32 cdw3, __u32 cdw10, + __u32 cdw11, __u32 cdw12, __u32 cdw13, __u32 cdw14, + __u32 cdw15, __u32 data_len, void *data, + __u32 metadata_len, void *metadata, __u32 timeout_ms, + __u32 *result) +{ + return nvme_passthru(fd, NVME_IOCTL_ADMIN_CMD, opcode, flags, rsvd, + nsid, cdw2, cdw3, cdw10, cdw11, cdw12, cdw13, + cdw14, cdw15, data_len, data, metadata_len, + metadata, timeout_ms, result); +} + +enum nvme_cmd_dword_fields { + NVME_DEVICE_SELF_TEST_CDW10_STC_SHIFT = 0, + NVME_DEVICE_SELF_TEST_CDW10_STC_MASK = 0x7, + NVME_DIRECTIVE_CDW11_DOPER_SHIFT = 0, + NVME_DIRECTIVE_CDW11_DTYPE_SHIFT = 8, + NVME_DIRECTIVE_CDW11_DPSEC_SHIFT = 16, + NVME_DIRECTIVE_CDW11_DOPER_MASK = 0xff, + NVME_DIRECTIVE_CDW11_DTYPE_MASK = 0xff, + NVME_DIRECTIVE_CDW11_DPSEC_MASK = 0xffff, + NVME_DIRECTIVE_SEND_IDENTIFY_CDW12_ENDIR_SHIFT = 0, + NVME_DIRECTIVE_SEND_IDENTIFY_CDW12_DTYPE_SHIFT = 1, + NVME_DIRECTIVE_SEND_IDENTIFY_CDW12_ENDIR_MASK = 0x1, + NVME_DIRECTIVE_SEND_IDENTIFY_CDW12_DTYPE_MASK = 0x1, + NVME_FW_COMMIT_CDW10_FS_SHIFT = 0, + NVME_FW_COMMIT_CDW10_CA_SHIFT = 3, + NVME_FW_COMMIT_CDW10_BPID_SHIFT = 31, + NVME_FW_COMMIT_CDW10_FS_MASK = 0x7, + NVME_FW_COMMIT_CDW10_CA_MASK = 0x7, + NVME_FW_COMMIT_CDW10_BPID_MASK = 0x1, + NVME_GET_FEATURES_CDW10_SEL_SHIFT = 8, + NVME_GET_FEATURES_CDW10_SEL_MASK = 0x7, + NVME_SET_FEATURES_CDW10_SAVE_SHIFT = 31, + NVME_SET_FEATURES_CDW10_SAVE_MASK = 0x1, + NVME_FEATURES_CDW10_FID_SHIFT = 0, + NVME_FEATURES_CDW14_UUID_SHIFT = 0, + NVME_FEATURES_CDW10_FID_MASK = 0xff, + NVME_FEATURES_CDW14_UUID_MASK = 0x7f, + NVME_LOG_CDW10_LID_SHIFT = 0, + NVME_LOG_CDW10_LSP_SHIFT = 8, + NVME_LOG_CDW10_RAE_SHIFT = 15, + NVME_LOG_CDW10_NUMDL_SHIFT = 16, + NVME_LOG_CDW11_NUMDU_SHIFT = 0, + NVME_LOG_CDW11_LSI_SHIFT = 16, + NVME_LOG_CDW14_UUID_SHIFT = 0, + NVME_LOG_CDW14_CSI_SHIFT = 24, + NVME_LOG_CDW14_OT_SHIFT = 23, + NVME_LOG_CDW10_LID_MASK = 0xff, + NVME_LOG_CDW10_LSP_MASK = 0xf, + NVME_LOG_CDW10_RAE_MASK = 0x1, + NVME_LOG_CDW10_NUMDL_MASK = 0xffff, + NVME_LOG_CDW11_NUMDU_MASK = 0xffff, + NVME_LOG_CDW11_LSI_MASK = 0xff, + NVME_LOG_CDW14_UUID_MASK = 0x7f, + NVME_LOG_CDW14_CSI_MASK = 0xff, + NVME_LOG_CDW14_OT_MASK = 0x1, + NVME_IDENTIFY_CDW10_CNS_SHIFT = 0, + NVME_IDENTIFY_CDW10_CNTID_SHIFT = 16, + NVME_IDENTIFY_CDW11_CNSSPECID_SHIFT = 0, + NVME_IDENTIFY_CDW14_UUID_SHIFT = 0, + NVME_IDENTIFY_CDW11_CSI_SHIFT = 24, + NVME_IDENTIFY_CDW10_CNS_MASK = 0xff, + NVME_IDENTIFY_CDW10_CNTID_MASK = 0xffff, + NVME_IDENTIFY_CDW11_CNSSPECID_MASK = 0xffff, + NVME_IDENTIFY_CDW14_UUID_MASK = 0x7f, + NVME_IDENTIFY_CDW11_CSI_MASK = 0xff, + NVME_NAMESPACE_ATTACH_CDW10_SEL_SHIFT = 0, + NVME_NAMESPACE_ATTACH_CDW10_SEL_MASK = 0xf, + NVME_NAMESPACE_MGMT_CDW10_SEL_SHIFT = 0, + NVME_NAMESPACE_MGMT_CDW10_SEL_MASK = 0xf, + NVME_NAMESPACE_MGMT_CDW11_CSI_SHIFT = 24, + NVME_NAMESPACE_MGMT_CDW11_CSI_MASK = 0xff, + NVME_VIRT_MGMT_CDW10_ACT_SHIFT = 0, + NVME_VIRT_MGMT_CDW10_RT_SHIFT = 8, + NVME_VIRT_MGMT_CDW10_CNTLID_SHIFT = 16, + NVME_VIRT_MGMT_CDW11_NR_SHIFT = 0, + NVME_VIRT_MGMT_CDW10_ACT_MASK = 0xf, + NVME_VIRT_MGMT_CDW10_RT_MASK = 0x7, + NVME_VIRT_MGMT_CDW10_CNTLID_MASK = 0xffff, + NVME_VIRT_MGMT_CDW11_NR_MASK = 0xffff, + NVME_FORMAT_CDW10_LBAF_SHIFT = 0, + NVME_FORMAT_CDW10_MSET_SHIFT = 4, + NVME_FORMAT_CDW10_PI_SHIFT = 5, + NVME_FORMAT_CDW10_PIL_SHIFT = 8, + NVME_FORMAT_CDW10_SES_SHIFT = 9, + NVME_FORMAT_CDW10_LBAF_MASK = 0xf, + NVME_FORMAT_CDW10_MSET_MASK = 0x1, + NVME_FORMAT_CDW10_PI_MASK = 0x7, + NVME_FORMAT_CDW10_PIL_MASK = 0x1, + NVME_FORMAT_CDW10_SES_MASK = 0x7, + NVME_SANITIZE_CDW10_SANACT_SHIFT = 0, + NVME_SANITIZE_CDW10_AUSE_SHIFT = 3, + NVME_SANITIZE_CDW10_OWPASS_SHIFT = 4, + NVME_SANITIZE_CDW10_OIPBP_SHIFT = 8, + NVME_SANITIZE_CDW10_NODAS_SHIFT = 9, + NVME_SANITIZE_CDW10_SANACT_MASK = 0x7, + NVME_SANITIZE_CDW10_AUSE_MASK = 0x1, + NVME_SANITIZE_CDW10_OWPASS_MASK = 0xf, + NVME_SANITIZE_CDW10_OIPBP_MASK = 0x1, + NVME_SANITIZE_CDW10_NODAS_MASK = 0x1, + NVME_SECURITY_NSSF_SHIFT = 0, + NVME_SECURITY_SPSP0_SHIFT = 8, + NVME_SECURITY_SPSP1_SHIFT = 16, + NVME_SECURITY_SECP_SHIFT = 24, + NVME_SECURITY_NSSF_MASK = 0xff, + NVME_SECURITY_SPSP0_MASK = 0xff, + NVME_SECURITY_SPSP1_MASK = 0xff, + NVME_SECURITY_SECP_MASK = 0xffff, + NVME_GET_LBA_STATUS_CDW13_RL_SHIFT = 0, + NVME_GET_LBA_STATUS_CDW13_ATYPE_SHIFT = 24, + NVME_GET_LBA_STATUS_CDW13_RL_MASK = 0xffff, + NVME_GET_LBA_STATUS_CDW13_ATYPE_MASK = 0xff, + NVME_ZNS_MGMT_SEND_ZSASO_SHIFT = 9, + NVME_ZNS_MGMT_SEND_ZSASO_MASK = 0x1, + NVME_ZNS_MGMT_SEND_SEL_SHIFT = 8, + NVME_ZNS_MGMT_SEND_SEL_MASK = 0x1, + NVME_ZNS_MGMT_SEND_ZSA_SHIFT = 0, + NVME_ZNS_MGMT_SEND_ZSA_MASK = 0xff, + NVME_ZNS_MGMT_RECV_ZRA_SHIFT = 0, + NVME_ZNS_MGMT_RECV_ZRA_MASK = 0xff, + NVME_ZNS_MGMT_RECV_ZRASF_SHIFT = 8, + NVME_ZNS_MGMT_RECV_ZRASF_MASK = 0xff, + NVME_ZNS_MGMT_RECV_ZRAS_FEAT_SHIFT = 16, + NVME_ZNS_MGMT_RECV_ZRAS_FEAT_MASK = 0x1, + NVME_DIM_TAS_SHIFT = 0, + NVME_DIM_TAS_MASK = 0xF, +}; + +enum features { + NVME_FEATURES_ARBITRATION_BURST_SHIFT = 0, + NVME_FEATURES_ARBITRATION_LPW_SHIFT = 8, + NVME_FEATURES_ARBITRATION_MPW_SHIFT = 16, + NVME_FEATURES_ARBITRATION_HPW_SHIFT = 24, + NVME_FEATURES_ARBITRATION_BURST_MASK = 0x7, + NVME_FEATURES_ARBITRATION_LPW_MASK = 0xff, + NVME_FEATURES_ARBITRATION_MPW_MASK = 0xff, + NVME_FEATURES_ARBITRATION_HPW_MASK = 0xff, + NVME_FEATURES_PWRMGMT_PS_SHIFT = 0, + NVME_FEATURES_PWRMGMT_WH_SHIFT = 5, + NVME_FEATURES_PWRMGMT_PS_MASK = 0x1f, + NVME_FEATURES_PWRMGMT_WH_MASK = 0x7, + NVME_FEATURES_TMPTH_SHIFT = 0, + NVME_FEATURES_TMPSEL_SHIFT = 16, + NVME_FEATURES_THSEL_SHIFT = 20, + NVME_FEATURES_TMPTH_MASK = 0xff, + NVME_FEATURES_TMPSEL_MASK = 0xf, + NVME_FEATURES_THSEL_MASK = 0x3, + NVME_FEATURES_ERROR_RECOVERY_TLER_SHIFT = 0, + NVME_FEATURES_ERROR_RECOVERY_DULBE_SHIFT = 16, + NVME_FEATURES_ERROR_RECOVERY_TLER_MASK = 0xff, + NVME_FEATURES_ERROR_RECOVERY_DULBE_MASK = 0x1, + NVME_FEATURES_VWC_WCE_SHIFT = 0, + NVME_FEATURES_VWC_WCE_MASK = 0x1, + NVME_FEATURES_IRQC_THR_SHIFT = 0, + NVME_FEATURES_IRQC_TIME_SHIFT = 8, + NVME_FEATURES_IRQC_THR_MASK = 0xff, + NVME_FEATURES_IRQC_TIME_MASK = 0xff, + NVME_FEATURES_IVC_IV_SHIFT = 0, + NVME_FEATURES_IVC_CD_SHIFT = 16, + NVME_FEATURES_IVC_IV_MASK = 0xffff, + NVME_FEATURES_IVC_CD_MASK = 0x1, + NVME_FEATURES_WAN_DN_SHIFT = 0, + NVME_FEATURES_WAN_DN_MASK = 0x1, + NVME_FEATURES_APST_APSTE_SHIFT = 0, + NVME_FEATURES_APST_APSTE_MASK = 0x1, + NVME_FEATURES_HCTM_TMT2_SHIFT = 0, + NVME_FEATURES_HCTM_TMT1_SHIFT = 16, + NVME_FEATURES_HCTM_TMT2_MASK = 0xffff, + NVME_FEATURES_HCTM_TMT1_MASK = 0xffff, + NVME_FEATURES_NOPS_NOPPME_SHIFT = 0, + NVME_FEATURES_NOPS_NOPPME_MASK = 0x1, + NVME_FEATURES_PLM_PLE_SHIFT = 0, + NVME_FEATURES_PLM_PLE_MASK = 0x1, + NVME_FEATURES_PLM_WINDOW_SELECT_SHIFT = 0, + NVME_FEATURES_PLM_WINDOW_SELECT_MASK = 0xf, + NVME_FEATURES_LBAS_LSIRI_SHIFT = 0, + NVME_FEATURES_LBAS_LSIPI_SHIFT = 16, + NVME_FEATURES_LBAS_LSIRI_MASK = 0xffff, + NVME_FEATURES_LBAS_LSIPI_MASK = 0xffff, + NVME_FEATURES_IOCSP_IOCSCI_SHIFT = 0, + NVME_FEATURES_IOCSP_IOCSCI_MASK = 0xff, +}; + +int nvme_identify(struct nvme_identify_args *args) +{ + __u32 cdw10 = NVME_SET(args->cntid, IDENTIFY_CDW10_CNTID) | + NVME_SET(args->cns, IDENTIFY_CDW10_CNS); + __u32 cdw11 = NVME_SET(args->cns_specific_id, IDENTIFY_CDW11_CNSSPECID) | + NVME_SET(args->csi, IDENTIFY_CDW11_CSI); + __u32 cdw14 = NVME_SET(args->uuidx, IDENTIFY_CDW14_UUID); + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_admin_identify, + .nsid = args->nsid, + .addr = (__u64)(uintptr_t)args->data, + .data_len = NVME_IDENTIFY_DATA_SIZE, + .cdw10 = cdw10, + .cdw11 = cdw11, + .cdw14 = cdw14, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_admin_passthru(args->fd, &cmd, args->result); +} + +int nvme_get_log(struct nvme_get_log_args *args) +{ + __u32 numd = (args->len >> 2) - 1; + __u16 numdu = numd >> 16, numdl = numd & 0xffff; + + __u32 cdw10 = NVME_SET(args->lid, LOG_CDW10_LID) | + NVME_SET(args->lsp, LOG_CDW10_LSP) | + NVME_SET(!!args->rae, LOG_CDW10_RAE) | + NVME_SET(numdl, LOG_CDW10_NUMDL); + __u32 cdw11 = NVME_SET(numdu, LOG_CDW11_NUMDU) | + NVME_SET(args->lsi, LOG_CDW11_LSI); + __u32 cdw12 = args->lpo & 0xffffffff; + __u32 cdw13 = args->lpo >> 32; + __u32 cdw14 = NVME_SET(args->uuidx, LOG_CDW14_UUID) | + NVME_SET(!!args->ot, LOG_CDW14_OT) | + NVME_SET(args->csi, LOG_CDW14_CSI); + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_admin_get_log_page, + .nsid = args->nsid, + .addr = (__u64)(uintptr_t)args->log, + .data_len = args->len, + .cdw10 = cdw10, + .cdw11 = cdw11, + .cdw12 = cdw12, + .cdw13 = cdw13, + .cdw14 = cdw14, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(struct nvme_get_log_args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_admin_passthru(args->fd, &cmd, args->result); +} + +int nvme_set_features(struct nvme_set_features_args *args) +{ + __u32 cdw10 = NVME_SET(args->fid, FEATURES_CDW10_FID) | + NVME_SET(!!args->save, SET_FEATURES_CDW10_SAVE); + __u32 cdw14 = NVME_SET(args->uuidx, FEATURES_CDW14_UUID); + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_admin_set_features, + .nsid = args->nsid, + .addr = (__u64)(uintptr_t)args->data, + .data_len = args->data_len, + .cdw10 = cdw10, + .cdw11 = args->cdw11, + .cdw12 = args->cdw12, + .cdw13 = args->cdw13, + .cdw14 = cdw14, + .cdw15 = args->cdw15, + .timeout_ms = args->timeout, + }; + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_admin_passthru(args->fd, &cmd, args->result); +} + +static int __nvme_set_features(int fd, __u8 fid, __u32 cdw11, bool save, + __u32 *result) +{ + struct nvme_set_features_args args = { + .args_size = sizeof(args), + .fd = fd, + .fid = fid, + .nsid = NVME_NSID_NONE, + .cdw11 = cdw11, + .cdw12 = 0, + .save = save, + .uuidx = NVME_UUID_NONE, + .cdw15 = 0, + .data_len = 0, + .data = NULL, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = result, + }; + return nvme_set_features(&args); +} + +int nvme_set_features_arbitration(int fd, __u8 ab, __u8 lpw, __u8 mpw, + __u8 hpw, bool save, __u32 *result) +{ + __u32 value = NVME_SET(ab, FEAT_ARBITRATION_BURST) | + NVME_SET(lpw, FEAT_ARBITRATION_LPW) | + NVME_SET(mpw, FEAT_ARBITRATION_MPW) | + NVME_SET(hpw, FEAT_ARBITRATION_HPW); + + return __nvme_set_features(fd, NVME_FEAT_FID_ARBITRATION, value, save, + result); +} + +int nvme_set_features_power_mgmt(int fd, __u8 ps, __u8 wh, bool save, + __u32 *result) +{ + __u32 value = NVME_SET(ps, FEAT_PWRMGMT_PS) | + NVME_SET(wh, FEAT_PWRMGMT_PS); + + return __nvme_set_features(fd, NVME_FEAT_FID_POWER_MGMT, value, save, + result); +} + +int nvme_set_features_lba_range(int fd, __u32 nsid, __u32 nr_ranges, bool save, + struct nvme_lba_range_type *data, __u32 *result) +{ + return -1; +} + +int nvme_set_features_temp_thresh(int fd, __u16 tmpth, __u8 tmpsel, + enum nvme_feat_tmpthresh_thsel thsel, + bool save, __u32 *result) +{ + __u32 value = NVME_SET(tmpth, FEAT_TT_TMPTH) | + NVME_SET(tmpsel, FEAT_TT_TMPSEL) | + NVME_SET(thsel, FEAT_TT_THSEL); + + return __nvme_set_features(fd, NVME_FEAT_FID_TEMP_THRESH, value, save, + result); +} + +int nvme_set_features_err_recovery(int fd, __u32 nsid, __u16 tler, bool dulbe, + bool save, __u32 *result) +{ + __u32 value = NVME_SET(tler, FEAT_ERROR_RECOVERY_TLER) | + NVME_SET(!!dulbe, FEAT_ERROR_RECOVERY_DULBE); + + return __nvme_set_features(fd, NVME_FEAT_FID_ERR_RECOVERY, value, save, + result); +} + +int nvme_set_features_volatile_wc(int fd, bool wce, bool save, __u32 *result) +{ + __u32 value = NVME_SET(!!wce, FEAT_VWC_WCE); + + return __nvme_set_features(fd, NVME_FEAT_FID_VOLATILE_WC, value, save, + result); +} + +int nvme_set_features_irq_coalesce(int fd, __u8 thr, __u8 time, bool save, + __u32 *result) +{ + __u32 value = NVME_SET(thr, FEAT_IRQC_TIME) | + NVME_SET(time, FEAT_IRQC_THR); + + return __nvme_set_features(fd, NVME_FEAT_FID_IRQ_COALESCE, value, save, + result); +} + +int nvme_set_features_irq_config(int fd, __u16 iv, bool cd, bool save, + __u32 *result) +{ + __u32 value = NVME_SET(iv, FEAT_ICFG_IV) | + NVME_SET(!!cd, FEAT_ICFG_CD); + + return __nvme_set_features(fd, NVME_FEAT_FID_IRQ_CONFIG, value, save, + result); +} + +int nvme_set_features_write_atomic(int fd, bool dn, bool save, __u32 *result) +{ + __u32 value = NVME_SET(!!dn, FEAT_WA_DN); + + return __nvme_set_features(fd, NVME_FEAT_FID_WRITE_ATOMIC, value, save, + result); +} + +int nvme_set_features_async_event(int fd, __u32 events, + bool save, __u32 *result) +{ + return __nvme_set_features(fd, NVME_FEAT_FID_ASYNC_EVENT, events, save, + result); +} + +int nvme_set_features_auto_pst(int fd, bool apste, bool save, + struct nvme_feat_auto_pst *apst, __u32 *result) +{ + __u32 value = NVME_SET(!!apste, FEAT_APST_APSTE); + + return __nvme_set_features(fd, NVME_FEAT_FID_AUTO_PST, value, save, + result); +} + +int nvme_set_features_timestamp(int fd, bool save, __u64 timestamp) +{ + __le64 t = cpu_to_le64(timestamp); + struct nvme_timestamp ts; + struct nvme_set_features_args args = { + .args_size = sizeof(args), + .fd = fd, + .nsid = NVME_NSID_NONE, + .cdw11 = 0, + .cdw12 = 0, + .save = save, + .uuidx = NVME_UUID_NONE, + .cdw15 = 0, + .data_len = sizeof(ts), + .data = &ts, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = NULL, + }; + + memcpy(ts.timestamp, &t, sizeof(ts.timestamp)); + return nvme_set_features(&args); +} + +int nvme_set_features_hctm(int fd, __u16 tmt2, __u16 tmt1, + bool save, __u32 *result) +{ + __u32 value = NVME_SET(tmt2, FEAT_HCTM_TMT2) | + NVME_SET(tmt1, FEAT_HCTM_TMT1); + + return __nvme_set_features(fd, NVME_FEAT_FID_HCTM, value, save, + result); +} + +int nvme_set_features_nopsc(int fd, bool noppme, bool save, __u32 *result) +{ + __u32 value = NVME_SET(noppme, FEAT_NOPS_NOPPME); + + return __nvme_set_features(fd, NVME_FEAT_FID_NOPSC, value, save, + result); +} + +int nvme_set_features_rrl(int fd, __u8 rrl, __u16 nvmsetid, + bool save, __u32 *result) +{ + struct nvme_set_features_args args = { + .args_size = sizeof(args), + .fd = fd, + .fid = NVME_FEAT_FID_RRL, + .nsid = NVME_NSID_NONE, + .cdw11 = nvmsetid, + .cdw12 = rrl, + .save = save, + .uuidx = NVME_UUID_NONE, + .cdw15 = 0, + .data_len = 0, + .data = NULL, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = result, + }; + + return nvme_set_features(&args); +} + +int nvme_set_features_plm_config(int fd, bool plm, __u16 nvmsetid, bool save, + struct nvme_plm_config *data, __u32 *result) +{ + struct nvme_set_features_args args = { + .args_size = sizeof(args), + .fd = fd, + .fid = NVME_FEAT_FID_PLM_CONFIG, + .nsid = NVME_NSID_NONE, + .cdw11 = nvmsetid, + .cdw12 = !!plm, + .save = save, + .uuidx = NVME_UUID_NONE, + .cdw15 = 0, + .data_len = 0, + .data = NULL, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = result, + }; + + return nvme_set_features(&args); +} + +int nvme_set_features_plm_window(int fd, enum nvme_feat_plm_window_select sel, + __u16 nvmsetid, bool save, __u32 *result) +{ + __u32 cdw12 = NVME_SET(sel, FEAT_PLMW_WS); + struct nvme_set_features_args args = { + .args_size = sizeof(args), + .fd = fd, + .fid = NVME_FEAT_FID_PLM_WINDOW, + .nsid = NVME_NSID_NONE, + .cdw11 = nvmsetid, + .cdw12 = cdw12, + .save = save, + .uuidx = NVME_UUID_NONE, + .cdw15 = 0, + .data_len = 0, + .data = NULL, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = result, + }; + + return nvme_set_features(&args); +} + +int nvme_set_features_lba_sts_interval(int fd, __u16 lsiri, __u16 lsipi, + bool save, __u32 *result) +{ + __u32 value = NVME_SET(lsiri, FEAT_LBAS_LSIRI) | + NVME_SET(lsipi, FEAT_LBAS_LSIPI); + + return __nvme_set_features(fd, NVME_FEAT_FID_LBA_STS_INTERVAL, value, + save, result); +} + +int nvme_set_features_host_behavior(int fd, bool save, + struct nvme_feat_host_behavior *data) +{ + struct nvme_set_features_args args = { + .args_size = sizeof(args), + .fd = fd, + .fid = NVME_FEAT_FID_HOST_BEHAVIOR, + .nsid = NVME_NSID_NONE, + .cdw11 = 0, + .cdw12 = 0, + .save = save, + .uuidx = NVME_UUID_NONE, + .cdw15 = 0, + .data_len = sizeof(*data), + .data = data, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = NULL, + }; + + return nvme_set_features(&args); +} + +int nvme_set_features_sanitize(int fd, bool nodrm, bool save, __u32 *result) +{ + return __nvme_set_features(fd, NVME_FEAT_FID_SANITIZE, !!nodrm, save, + result); +} + +int nvme_set_features_endurance_evt_cfg(int fd, __u16 endgid, __u8 egwarn, + bool save, __u32 *result) +{ + __u32 value = endgid | egwarn << 16; + + return __nvme_set_features(fd, NVME_FEAT_FID_ENDURANCE_EVT_CFG, value, + save, result); +} + +int nvme_set_features_sw_progress(int fd, __u8 pbslc, bool save, + __u32 *result) +{ + return __nvme_set_features(fd, NVME_FEAT_FID_SW_PROGRESS, pbslc, save, + result); +} + +int nvme_set_features_host_id(int fd, bool save, bool exhid, __u8 *hostid) +{ + __u32 len = exhid ? 16 : 8; + __u32 value = !!exhid; + struct nvme_set_features_args args = { + .args_size = sizeof(args), + .fd = fd, + .fid = NVME_FEAT_FID_HOST_ID, + .nsid = NVME_NSID_NONE, + .cdw11 = value, + .cdw12 = 0, + .save = save, + .uuidx = NVME_UUID_NONE, + .cdw15 = 0, + .data_len = len, + .data = hostid, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = NULL, + }; + + return nvme_set_features(&args); +} + +int nvme_set_features_resv_mask(int fd, __u32 mask, bool save, __u32 *result) +{ + return __nvme_set_features(fd, NVME_FEAT_FID_RESV_MASK, mask, save, + result); +} + +int nvme_set_features_resv_persist(int fd, bool ptpl, bool save, __u32 *result) +{ + return __nvme_set_features(fd, NVME_FEAT_FID_RESV_PERSIST, !!ptpl, save, + result); +} + +int nvme_set_features_write_protect(int fd, enum nvme_feat_nswpcfg_state state, + bool save, __u32 *result) +{ + return __nvme_set_features(fd, NVME_FEAT_FID_WRITE_PROTECT, state, + save, result); +} + +int nvme_set_features_iocs_profile(int fd, __u8 iocsi, bool save) +{ + __u32 value = NVME_SET(iocsi, FEAT_IOCSP_IOCSCI); + + return __nvme_set_features(fd, NVME_FEAT_FID_IOCS_PROFILE, value, + save, NULL); +} + +int nvme_get_features(struct nvme_get_features_args *args) +{ + __u32 cdw10 = NVME_SET(args->fid, FEATURES_CDW10_FID) | + NVME_SET(args->sel, GET_FEATURES_CDW10_SEL); + __u32 cdw14 = NVME_SET(args->uuidx, FEATURES_CDW14_UUID); + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_admin_get_features, + .nsid = args->nsid, + .addr = (__u64)(uintptr_t)args->data, + .data_len = args->data_len, + .cdw10 = cdw10, + .cdw11 = args->cdw11, + .cdw14 = cdw14, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_admin_passthru(args->fd, &cmd, args->result); +} + +static int __nvme_get_features(int fd, enum nvme_features_id fid, + enum nvme_get_features_sel sel, __u32 *result) +{ + struct nvme_get_features_args args = { + .args_size = sizeof(args), + .fd = fd, + .fid = fid, + .nsid = NVME_NSID_NONE, + .sel = sel, + .cdw11 = 0, + .uuidx = NVME_UUID_NONE, + .data_len = 0, + .data = NULL, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = result, + }; + + return nvme_get_features(&args); +} + +int nvme_get_features_arbitration(int fd, enum nvme_get_features_sel sel, + __u32 *result) +{ + return __nvme_get_features(fd, NVME_FEAT_FID_ARBITRATION, sel, result); +} + +int nvme_get_features_power_mgmt(int fd, enum nvme_get_features_sel sel, + __u32 *result) +{ + return __nvme_get_features(fd, NVME_FEAT_FID_POWER_MGMT, sel, result); +} + +int nvme_get_features_lba_range(int fd, enum nvme_get_features_sel sel, + struct nvme_lba_range_type *data, + __u32 *result) +{ + struct nvme_get_features_args args = { + .args_size = sizeof(args), + .fd = fd, + .fid = NVME_FEAT_FID_LBA_RANGE, + .nsid = NVME_NSID_NONE, + .sel = sel, + .cdw11 = 0, + .uuidx = NVME_UUID_NONE, + .data_len = 0, + .data = NULL, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = result, + }; + + return nvme_get_features(&args); +} + +int nvme_get_features_temp_thresh(int fd, enum nvme_get_features_sel sel, + __u32 *result) +{ + return __nvme_get_features(fd, NVME_FEAT_FID_TEMP_THRESH, sel, result); +} + +int nvme_get_features_err_recovery(int fd, enum nvme_get_features_sel sel, + __u32 *result) +{ + return __nvme_get_features(fd, NVME_FEAT_FID_ERR_RECOVERY, sel, + result); +} + +int nvme_get_features_volatile_wc(int fd, enum nvme_get_features_sel sel, + __u32 *result) +{ + return __nvme_get_features(fd, NVME_FEAT_FID_VOLATILE_WC, sel, result); +} + +int nvme_get_features_num_queues(int fd, enum nvme_get_features_sel sel, + __u32 *result) +{ + return __nvme_get_features(fd, NVME_FEAT_FID_NUM_QUEUES, sel, result); +} + +int nvme_get_features_irq_coalesce(int fd, enum nvme_get_features_sel sel, + __u32 *result) +{ + return __nvme_get_features(fd, NVME_FEAT_FID_IRQ_COALESCE, sel, + result); +} + +int nvme_get_features_irq_config(int fd, enum nvme_get_features_sel sel, + __u16 iv, __u32 *result) +{ + struct nvme_get_features_args args = { + .args_size = sizeof(args), + .fd = fd, + .fid = NVME_FEAT_FID_LBA_RANGE, + .nsid = NVME_NSID_NONE, + .sel = sel, + .cdw11 = iv, + .uuidx = NVME_UUID_NONE, + .data_len = 0, + .data = NULL, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = result, + }; + + return nvme_get_features(&args); +} + +int nvme_get_features_write_atomic(int fd, enum nvme_get_features_sel sel, + __u32 *result) +{ + return __nvme_get_features(fd, NVME_FEAT_FID_WRITE_ATOMIC, sel, + result); +} + +int nvme_get_features_async_event(int fd, enum nvme_get_features_sel sel, + __u32 *result) +{ + return __nvme_get_features(fd, NVME_FEAT_FID_ASYNC_EVENT, sel, result); +} + +int nvme_get_features_auto_pst(int fd, enum nvme_get_features_sel sel, + struct nvme_feat_auto_pst *apst, __u32 *result) +{ + struct nvme_get_features_args args = { + .args_size = sizeof(args), + .fd = fd, + .fid = NVME_FEAT_FID_LBA_RANGE, + .nsid = NVME_NSID_NONE, + .sel = sel, + .cdw11 = 0, + .uuidx = NVME_UUID_NONE, + .data_len = 0, + .data = NULL, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = result, + }; + + return nvme_get_features(&args); +} + +int nvme_get_features_host_mem_buf(int fd, enum nvme_get_features_sel sel, + __u32 *result) +{ + return __nvme_get_features(fd, NVME_FEAT_FID_HOST_MEM_BUF, sel, result); +} + +int nvme_get_features_timestamp(int fd, enum nvme_get_features_sel sel, + struct nvme_timestamp *ts) +{ + struct nvme_get_features_args args = { + .args_size = sizeof(args), + .fd = fd, + .fid = NVME_FEAT_FID_TIMESTAMP, + .nsid = NVME_NSID_NONE, + .sel = sel, + .cdw11 = 0, + .uuidx = NVME_UUID_NONE, + .data_len = sizeof(*ts), + .data = ts, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = NULL, + }; + + return nvme_get_features(&args); +} + +int nvme_get_features_kato(int fd, enum nvme_get_features_sel sel, __u32 *result) +{ + return __nvme_get_features(fd, NVME_FEAT_FID_KATO, sel, result); +} + +int nvme_get_features_hctm(int fd, enum nvme_get_features_sel sel, __u32 *result) +{ + return __nvme_get_features(fd, NVME_FEAT_FID_HCTM, sel, result); +} + +int nvme_get_features_nopsc(int fd, enum nvme_get_features_sel sel, __u32 *result) +{ + return __nvme_get_features(fd, NVME_FEAT_FID_NOPSC, sel, result); +} + +int nvme_get_features_rrl(int fd, enum nvme_get_features_sel sel, __u32 *result) +{ + return __nvme_get_features(fd, NVME_FEAT_FID_RRL, sel, result); +} + +int nvme_get_features_plm_config(int fd, enum nvme_get_features_sel sel, + __u16 nvmsetid, struct nvme_plm_config *data, + __u32 *result) +{ + struct nvme_get_features_args args = { + .args_size = sizeof(args), + .fd = fd, + .fid = NVME_FEAT_FID_PLM_CONFIG, + .nsid = NVME_NSID_NONE, + .sel = sel, + .cdw11 = nvmsetid, + .uuidx = NVME_UUID_NONE, + .data_len = 0, + .data = NULL, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = result, + }; + + return nvme_get_features(&args); +} + +int nvme_get_features_plm_window(int fd, enum nvme_get_features_sel sel, + __u16 nvmsetid, __u32 *result) +{ + struct nvme_get_features_args args = { + .args_size = sizeof(args), + .fd = fd, + .fid = NVME_FEAT_FID_PLM_WINDOW, + .nsid = NVME_NSID_NONE, + .sel = sel, + .cdw11 = nvmsetid, + .uuidx = NVME_UUID_NONE, + .data_len = 0, + .data = NULL, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = result, + }; + + return nvme_get_features(&args); +} + +int nvme_get_features_lba_sts_interval(int fd, enum nvme_get_features_sel sel, + __u32 *result) +{ + return __nvme_get_features(fd, NVME_FEAT_FID_LBA_STS_INTERVAL, sel, + result); +} + +int nvme_get_features_host_behavior(int fd, enum nvme_get_features_sel sel, + struct nvme_feat_host_behavior *data, + __u32 *result) +{ + struct nvme_get_features_args args = { + .args_size = sizeof(args), + .fd = fd, + .fid = NVME_FEAT_FID_HOST_BEHAVIOR, + .nsid = NVME_NSID_NONE, + .sel = sel, + .cdw11 = 0, + .uuidx = NVME_UUID_NONE, + .data_len = 0, + .data = NULL, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = result, + }; + + return nvme_get_features(&args); +} + +int nvme_get_features_sanitize(int fd, enum nvme_get_features_sel sel, + __u32 *result) +{ + return __nvme_get_features(fd, NVME_FEAT_FID_SANITIZE, sel, result); +} + +int nvme_get_features_endurance_event_cfg(int fd, enum nvme_get_features_sel sel, + __u16 endgid, __u32 *result) +{ + struct nvme_get_features_args args = { + .args_size = sizeof(args), + .fd = fd, + .fid = NVME_FEAT_FID_ENDURANCE_EVT_CFG, + .nsid = NVME_NSID_NONE, + .sel = sel, + .cdw11 = 0, + .uuidx = NVME_UUID_NONE, + .data_len = 0, + .data = NULL, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = result, + }; + + return nvme_get_features(&args); +} + +int nvme_get_features_sw_progress(int fd, enum nvme_get_features_sel sel, + __u32 *result) +{ + return __nvme_get_features(fd, NVME_FEAT_FID_SW_PROGRESS, sel, result); +} + +int nvme_get_features_host_id(int fd, enum nvme_get_features_sel sel, + bool exhid, __u32 len, __u8 *hostid) +{ + struct nvme_get_features_args args = { + .args_size = sizeof(args), + .fd = fd, + .fid = NVME_FEAT_FID_HOST_ID, + .nsid = NVME_NSID_NONE, + .sel = sel, + .cdw11 = !!exhid, + .uuidx = NVME_UUID_NONE, + .data_len = len, + .data = hostid, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = NULL, + }; + + return nvme_get_features(&args); +} + +int nvme_get_features_resv_mask(int fd, enum nvme_get_features_sel sel, + __u32 *result) +{ + return __nvme_get_features(fd, NVME_FEAT_FID_RESV_MASK, sel, result); +} + +int nvme_get_features_resv_persist(int fd, enum nvme_get_features_sel sel, + __u32 *result) +{ + return __nvme_get_features(fd, NVME_FEAT_FID_RESV_PERSIST, sel, result); +} + +int nvme_get_features_write_protect(int fd, __u32 nsid, + enum nvme_get_features_sel sel, + __u32 *result) +{ + struct nvme_get_features_args args = { + .args_size = sizeof(args), + .fd = fd, + .fid = NVME_FEAT_FID_WRITE_PROTECT, + .nsid = nsid, + .sel = sel, + .cdw11 = 0, + .uuidx = NVME_UUID_NONE, + .data_len = 0, + .data = NULL, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = result, + }; + + return nvme_get_features(&args); +} + +int nvme_get_features_iocs_profile(int fd, enum nvme_get_features_sel sel, + __u32 *result) +{ + return __nvme_get_features(fd, NVME_FEAT_FID_IOCS_PROFILE, sel, result); +} + +int nvme_format_nvm(struct nvme_format_nvm_args *args) +{ + __u32 cdw10 = NVME_SET(args->lbaf, FORMAT_CDW10_LBAF) | + NVME_SET(args->mset, FORMAT_CDW10_MSET) | + NVME_SET(args->pi, FORMAT_CDW10_PI) | + NVME_SET(args->pil, FORMAT_CDW10_PIL) | + NVME_SET(args->ses, FORMAT_CDW10_SES); + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_admin_format_nvm, + .nsid = args->nsid, + .cdw10 = cdw10, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_admin_passthru(args->fd, &cmd, args->result); +} + +int nvme_ns_mgmt(struct nvme_ns_mgmt_args *args) +{ + __u32 cdw10 = NVME_SET(args->sel, NAMESPACE_MGMT_CDW10_SEL); + __u32 cdw11 = NVME_SET(args->csi, NAMESPACE_MGMT_CDW11_CSI); + __u32 data_len = args->ns ? sizeof(*args->ns) : 0; + + struct nvme_passthru_cmd cmd = { + .nsid = args->nsid, + .opcode = nvme_admin_ns_mgmt, + .cdw10 = cdw10, + .cdw11 = cdw11, + .timeout_ms = args->timeout, + .data_len = data_len, + .addr = (__u64)(uintptr_t)args->ns, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_admin_passthru(args->fd, &cmd, args->result); +} + +int nvme_ns_attach(struct nvme_ns_attach_args *args) +{ + __u32 cdw10 = NVME_SET(args->sel, NAMESPACE_ATTACH_CDW10_SEL); + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_admin_ns_attach, + .nsid = args->nsid, + .cdw10 = cdw10, + .data_len = sizeof(*args->ctrlist), + .addr = (__u64)(uintptr_t)args->ctrlist, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_admin_passthru(args->fd, &cmd, args->result); +} + +int nvme_fw_download(struct nvme_fw_download_args *args) +{ + __u32 cdw10 = (args->data_len >> 2) - 1; + __u32 cdw11 = args->offset >> 2; + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_admin_fw_download, + .cdw10 = cdw10, + .cdw11 = cdw11, + .data_len = args->data_len, + .addr = (__u64)(uintptr_t)args->data, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_admin_passthru(args->fd, &cmd, args->result); +} + +int nvme_fw_commit(struct nvme_fw_commit_args *args) +{ + __u32 cdw10 = NVME_SET(args->slot, FW_COMMIT_CDW10_FS) | + NVME_SET(args->action, FW_COMMIT_CDW10_CA) | + NVME_SET(args->bpid, FW_COMMIT_CDW10_BPID); + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_admin_fw_commit, + .cdw10 = cdw10, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_admin_passthru(args->fd, &cmd, args->result); +} + +int nvme_security_send(struct nvme_security_send_args *args) +{ + __u32 cdw10 = NVME_SET(args->secp, SECURITY_SECP) | + NVME_SET(args->spsp0, SECURITY_SPSP0) | + NVME_SET(args->spsp1, SECURITY_SPSP1) | + NVME_SET(args->nssf, SECURITY_NSSF); + __u32 cdw11 = args->tl; + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_admin_security_send, + .nsid = args->nsid, + .cdw10 = cdw10, + .cdw11 = cdw11, + .data_len = args->data_len, + .addr = (__u64)(uintptr_t)args->data, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_admin_passthru(args->fd, &cmd, args->result); +} + +int nvme_security_receive(struct nvme_security_receive_args *args) +{ + __u32 cdw10 = NVME_SET(args->secp, SECURITY_SECP) | + NVME_SET(args->spsp0, SECURITY_SPSP0) | + NVME_SET(args->spsp1, SECURITY_SPSP1) | + NVME_SET(args->nssf, SECURITY_NSSF); + __u32 cdw11 = args->al; + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_admin_security_recv, + .nsid = args->nsid, + .cdw10 = cdw10, + .cdw11 = cdw11, + .data_len = args->data_len, + .addr = (__u64)(uintptr_t)args->data, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_admin_passthru(args->fd, &cmd, args->result); +} + +int nvme_get_lba_status(struct nvme_get_lba_status_args *args) +{ + __u32 cdw10 = args->slba & 0xffffffff; + __u32 cdw11 = args->slba >> 32; + __u32 cdw12 = args->mndw; + __u32 cdw13 = NVME_SET(args->rl, GET_LBA_STATUS_CDW13_RL) | + NVME_SET(args->atype, GET_LBA_STATUS_CDW13_ATYPE); + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_admin_get_lba_status, + .nsid = args->nsid, + .addr = (__u64)(uintptr_t)args->lbas, + .cdw10 = cdw10, + .cdw11 = cdw11, + .cdw12 = cdw12, + .cdw13 = cdw13, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_admin_passthru(args->fd, &cmd, args->result); +} + +int nvme_directive_send(struct nvme_directive_send_args *args) +{ + __u32 cdw10 = args->data_len ? (args->data_len >> 2) - 1 : 0; + __u32 cdw11 = NVME_SET(args->doper, DIRECTIVE_CDW11_DOPER) | + NVME_SET(args->dtype, DIRECTIVE_CDW11_DTYPE) | + NVME_SET(args->dspec, DIRECTIVE_CDW11_DPSEC); + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_admin_directive_send, + .nsid = args->nsid, + .cdw10 = cdw10, + .cdw11 = cdw11, + .cdw12 = args->cdw12, + .data_len = args->data_len, + .addr = (__u64)(uintptr_t)args->data, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_admin_passthru(args->fd, &cmd, args->result); +} + +int nvme_directive_send_id_endir(int fd, __u32 nsid, bool endir, + enum nvme_directive_dtype dtype, + struct nvme_id_directives *id) +{ + __u32 cdw12 = NVME_SET(dtype, DIRECTIVE_SEND_IDENTIFY_CDW12_DTYPE) | + NVME_SET(endir, DIRECTIVE_SEND_IDENTIFY_CDW12_ENDIR); + struct nvme_directive_send_args args = { + .args_size = sizeof(args), + .fd = fd, + .nsid = nsid, + .dspec = 0, + .dtype = NVME_DIRECTIVE_DTYPE_IDENTIFY, + .doper = NVME_DIRECTIVE_SEND_IDENTIFY_DOPER_ENDIR, + .cdw12 = cdw12, + .data_len = sizeof(*id), + .data = id, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = NULL, + }; + + return nvme_directive_send(&args); +} + +int nvme_directive_recv(struct nvme_directive_recv_args *args) +{ + __u32 cdw10 = args->data_len ? (args->data_len >> 2) - 1 : 0; + __u32 cdw11 = NVME_SET(args->doper, DIRECTIVE_CDW11_DOPER) | + NVME_SET(args->dtype, DIRECTIVE_CDW11_DTYPE) | + NVME_SET(args->dspec, DIRECTIVE_CDW11_DPSEC); + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_admin_directive_recv, + .nsid = args->nsid, + .cdw10 = cdw10, + .cdw11 = cdw11, + .cdw12 = args->cdw12, + .data_len = args->data_len, + .addr = (__u64)(uintptr_t)args->data, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_admin_passthru(args->fd, &cmd, args->result); +} + +int nvme_capacity_mgmt(struct nvme_capacity_mgmt_args *args) +{ + __u32 cdw10 = args->op | args->element_id << 16; + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_admin_capacity_mgmt, + .cdw10 = cdw10, + .cdw11 = args->cdw11, + .cdw12 = args->cdw12, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_admin_passthru(args->fd, &cmd, args->result); +} + +int nvme_lockdown(struct nvme_lockdown_args *args) +{ + __u32 cdw10 = args->ofi << 8 | + (args->ifc & 0x3) << 5 | + (args->prhbt & 0x1) << 4 | + (args->scp & 0xF); + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_admin_lockdown, + .cdw10 = cdw10, + .cdw14 = args->uuidx & 0x3F, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_admin_passthru(args->fd, &cmd, args->result); +} + +int nvme_set_property(struct nvme_set_property_args *args) +{ + __u32 cdw10 = nvme_is_64bit_reg(args->offset); + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_admin_fabrics, + .nsid = nvme_fabrics_type_property_set, + .cdw10 = cdw10, + .cdw11 = args->offset, + .cdw12 = args->value & 0xffffffff, + .cdw13 = args->value >> 32, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_admin_passthru(args->fd, &cmd, args->result); +} + +int nvme_get_property(struct nvme_get_property_args *args) +{ + __u32 cdw10 = nvme_is_64bit_reg(args->offset); + + struct nvme_passthru_cmd64 cmd = { + .opcode = nvme_admin_fabrics, + .nsid = nvme_fabrics_type_property_get, + .cdw10 = cdw10, + .cdw11 = args->offset, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_admin_passthru64(args->fd, &cmd, args->value); +} + +int nvme_sanitize_nvm(struct nvme_sanitize_nvm_args *args) +{ + __u32 cdw10 = NVME_SET(args->sanact, SANITIZE_CDW10_SANACT) | + NVME_SET(!!args->ause, SANITIZE_CDW10_AUSE) | + NVME_SET(args->owpass, SANITIZE_CDW10_OWPASS) | + NVME_SET(!!args->oipbp, SANITIZE_CDW10_OIPBP) | + NVME_SET(!!args->nodas, SANITIZE_CDW10_NODAS); + __u32 cdw11 = args->ovrpat; + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_admin_sanitize_nvm, + .cdw10 = cdw10, + .cdw11 = cdw11, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_admin_passthru(args->fd, &cmd, args->result); +} + +int nvme_dev_self_test(struct nvme_dev_self_test_args *args) +{ + __u32 cdw10 = NVME_SET(args->stc, DEVICE_SELF_TEST_CDW10_STC); + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_admin_dev_self_test, + .nsid = args->nsid, + .cdw10 = cdw10, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_admin_passthru(args->fd, &cmd, args->result); +} + +int nvme_virtual_mgmt(struct nvme_virtual_mgmt_args *args) +{ + __u32 cdw10 = NVME_SET(args->act, VIRT_MGMT_CDW10_ACT) | + NVME_SET(args->rt, VIRT_MGMT_CDW10_RT) | + NVME_SET(args->cntlid, VIRT_MGMT_CDW10_CNTLID); + __u32 cdw11 = NVME_SET(args->nr, VIRT_MGMT_CDW11_NR); + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_admin_virtual_mgmt, + .cdw10 = cdw10, + .cdw11 = cdw11, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_admin_passthru(args->fd, &cmd, args->result); +} + +int nvme_submit_io_passthru64(int fd, struct nvme_passthru_cmd64 *cmd, + __u64 *result) +{ + return nvme_submit_passthru64(fd, NVME_IOCTL_IO64_CMD, cmd, result); +} + +int nvme_io_passthru64(int fd, __u8 opcode, __u8 flags, __u16 rsvd, + __u32 nsid, __u32 cdw2, __u32 cdw3, __u32 cdw10, + __u32 cdw11, __u32 cdw12, __u32 cdw13, __u32 cdw14, + __u32 cdw15, __u32 data_len, void *data, __u32 metadata_len, + void *metadata, __u32 timeout_ms, __u64 *result) +{ + return nvme_passthru64(fd, NVME_IOCTL_IO64_CMD, opcode, flags, rsvd, + nsid, cdw2, cdw3, cdw10, cdw11, cdw12, cdw13, + cdw14, cdw15, data_len, data, metadata_len, metadata, + timeout_ms, result); +} + +int nvme_submit_io_passthru(int fd, struct nvme_passthru_cmd *cmd, __u32 *result) +{ + return nvme_submit_passthru(fd, NVME_IOCTL_IO_CMD, cmd, result); +} + +int nvme_io_passthru(int fd, __u8 opcode, __u8 flags, __u16 rsvd, + __u32 nsid, __u32 cdw2, __u32 cdw3, __u32 cdw10, + __u32 cdw11, __u32 cdw12, __u32 cdw13, __u32 cdw14, + __u32 cdw15, __u32 data_len, void *data, __u32 metadata_len, + void *metadata, __u32 timeout_ms, __u32 *result) +{ + return nvme_passthru(fd, NVME_IOCTL_IO_CMD, opcode, flags, rsvd, nsid, + cdw2, cdw3, cdw10, cdw11, cdw12, cdw13, cdw14, + cdw15, data_len, data, metadata_len, metadata, + timeout_ms, result); +} + +int nvme_io(struct nvme_io_args *args, __u8 opcode) +{ + __u32 cdw2 = args->storage_tag & 0xffffffff; + __u32 cdw3 = (args->storage_tag >> 32) & 0xffff; + __u32 cdw10 = args->slba & 0xffffffff; + __u32 cdw11 = args->slba >> 32; + __u32 cdw12 = args->nlb | (args->control << 16); + __u32 cdw13 = args->dsm | (args->dspec << 16); + __u32 cdw14 = args->reftag; + __u32 cdw15 = args->apptag | (args->appmask << 16); + + struct nvme_passthru_cmd cmd = { + .opcode = opcode, + .nsid = args->nsid, + .cdw2 = cdw2, + .cdw3 = cdw3, + .cdw10 = cdw10, + .cdw11 = cdw11, + .cdw12 = cdw12, + .cdw13 = cdw13, + .cdw14 = cdw14, + .cdw15 = cdw15, + .data_len = args->data_len, + .metadata_len = args->metadata_len, + .addr = (__u64)(uintptr_t)args->data, + .metadata = (__u64)(uintptr_t)args->metadata, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_io_passthru(args->fd, &cmd, args->result); +} + +int nvme_dsm(struct nvme_dsm_args *args) +{ + struct nvme_passthru_cmd cmd = { + .opcode = nvme_cmd_dsm, + .nsid = args->nsid, + .addr = (__u64)(uintptr_t)args->dsm, + .data_len = args->nr_ranges * sizeof(*args->dsm), + .cdw10 = args->nr_ranges - 1, + .cdw11 = args->attrs, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_io_passthru(args->fd, &cmd, args->result); +} + +int nvme_copy(struct nvme_copy_args *args) +{ + __u32 cdw12 = ((args->nr - 1) & 0xff) | ((args->format & 0xf) << 8) | + ((args->prinfor & 0xf) << 12) | ((args->dtype & 0xf) << 20) | + ((args->prinfow & 0xf) << 26) | ((args->fua & 0x1) << 30) | + ((args->lr & 0x1) << 31); + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_cmd_copy, + .nsid = args->nsid, + .addr = (__u64)(uintptr_t)args->copy, + .data_len = args->nr * sizeof(*args->copy), + .cdw10 = args->sdlba & 0xffffffff, + .cdw11 = args->sdlba >> 32, + .cdw12 = cdw12, + .cdw13 = (args->dspec & 0xffff) << 16, + .cdw14 = args->ilbrt, + .cdw15 = (args->lbatm << 16) | args->lbat, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_io_passthru(args->fd, &cmd, args->result); +} + +int nvme_resv_acquire(struct nvme_resv_acquire_args *args) +{ + __le64 payload[2] = { + cpu_to_le64(args->crkey), + cpu_to_le64(args->nrkey) + }; + __u32 cdw10 = (args->racqa & 0x7) | + (args->iekey ? 1 << 3 : 0) | + (args->rtype << 8); + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_cmd_resv_acquire, + .nsid = args->nsid, + .cdw10 = cdw10, + .data_len = sizeof(payload), + .addr = (__u64)(uintptr_t)(payload), + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_io_passthru(args->fd, &cmd, args->result); +} + +int nvme_resv_register(struct nvme_resv_register_args *args) +{ + __le64 payload[2] = { + cpu_to_le64(args->crkey), + cpu_to_le64(args->nrkey) + }; + __u32 cdw10 = (args->rrega & 0x7) | + (args->iekey ? 1 << 3 : 0) | + (args->cptpl << 30); + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_cmd_resv_register, + .nsid = args->nsid, + .cdw10 = cdw10, + .data_len = sizeof(payload), + .addr = (__u64)(uintptr_t)(payload), + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_io_passthru(args->fd, &cmd, args->result); +} + +int nvme_resv_release(struct nvme_resv_release_args *args) +{ + __le64 payload[1] = { cpu_to_le64(args->crkey) }; + __u32 cdw10 = (args->rrela & 0x7) | + (args->iekey ? 1 << 3 : 0) | + (args->rtype << 8); + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_cmd_resv_release, + .nsid = args->nsid, + .cdw10 = cdw10, + .addr = (__u64)(uintptr_t)(payload), + .data_len = sizeof(payload), + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_io_passthru(args->fd, &cmd, args->result); +} + +int nvme_resv_report(struct nvme_resv_report_args *args) +{ + struct nvme_passthru_cmd cmd = { + .opcode = nvme_cmd_resv_report, + .nsid = args->nsid, + .cdw10 = (args->len >> 2) - 1, + .cdw11 = args->eds ? 1 : 0, + .addr = (__u64)(uintptr_t)args->report, + .data_len = args->len, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_io_passthru(args->fd, &cmd, args->result); +} + +int nvme_zns_mgmt_send(struct nvme_zns_mgmt_send_args *args) +{ + __u32 cdw10 = args->slba & 0xffffffff; + __u32 cdw11 = args->slba >> 32; + __u32 cdw13 = NVME_SET(args->zsaso, ZNS_MGMT_SEND_ZSASO) | + NVME_SET(!!args->select_all, ZNS_MGMT_SEND_SEL) | + NVME_SET(args->zsa, ZNS_MGMT_SEND_ZSA); + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_zns_cmd_mgmt_send, + .nsid = args->nsid, + .cdw10 = cdw10, + .cdw11 = cdw11, + .cdw13 = cdw13, + .addr = (__u64)(uintptr_t)args->data, + .data_len = args->data_len, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_io_passthru(args->fd, &cmd, args->result); +} + +int nvme_zns_mgmt_recv(struct nvme_zns_mgmt_recv_args *args) +{ + __u32 cdw10 = args->slba & 0xffffffff; + __u32 cdw11 = args->slba >> 32; + __u32 cdw12 = (args->data_len >> 2) - 1; + __u32 cdw13 = NVME_SET(args->zra, ZNS_MGMT_RECV_ZRA) | + NVME_SET(args->zrasf, ZNS_MGMT_RECV_ZRASF) | + NVME_SET(args->zras_feat, ZNS_MGMT_RECV_ZRAS_FEAT); + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_zns_cmd_mgmt_recv, + .nsid = args->nsid, + .cdw10 = cdw10, + .cdw11 = cdw11, + .cdw12 = cdw12, + .cdw13 = cdw13, + .addr = (__u64)(uintptr_t)args->data, + .data_len = args->data_len, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_io_passthru(args->fd, &cmd, args->result); +} + +int nvme_zns_append(struct nvme_zns_append_args *args) +{ + __u32 cdw10 = args->zslba & 0xffffffff; + __u32 cdw11 = args->zslba >> 32; + __u32 cdw12 = args->nlb | (args->control << 16); + __u32 cdw14 = args->ilbrt; + __u32 cdw15 = args->lbat | (args->lbatm << 16); + + struct nvme_passthru_cmd64 cmd = { + .opcode = nvme_zns_cmd_append, + .nsid = args->nsid, + .cdw10 = cdw10, + .cdw11 = cdw11, + .cdw12 = cdw12, + .cdw14 = cdw14, + .cdw15 = cdw15, + .data_len = args->data_len, + .addr = (__u64)(uintptr_t)args->data, + .metadata_len = args->metadata_len, + .metadata = (__u64)(uintptr_t)args->metadata, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + return nvme_submit_io_passthru64(args->fd, &cmd, args->result); +} + +int nvme_dim_send(struct nvme_dim_args *args) +{ + __u32 cdw10 = NVME_SET(args->tas, DIM_TAS); + + struct nvme_passthru_cmd cmd = { + .opcode = nvme_admin_discovery_info_mgmt, + .cdw10 = cdw10, + .addr = (__u64)(uintptr_t)args->data, + .data_len = args->data_len, + .timeout_ms = args->timeout, + }; + + if (args->args_size < sizeof(*args)) { + errno = EINVAL; + return -1; + } + + return nvme_submit_admin_passthru(args->fd, &cmd, args->result); +} diff --git a/src/nvme/ioctl.h b/src/nvme/ioctl.h new file mode 100644 index 0000000..ab3797d --- /dev/null +++ b/src/nvme/ioctl.h @@ -0,0 +1,4407 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/* + * This file is part of libnvme. + * Copyright (c) 2020 Western Digital Corporation or its affiliates. + * + * Authors: Keith Busch <keith.busch@wdc.com> + * Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com> + */ + +#ifndef _LIBNVME_IOCTL_H +#define _LIBNVME_IOCTL_H + +#include <stddef.h> +#include <sys/ioctl.h> +#include "types.h" + +/* + * We can not always count on the kernel UAPI being installed. Use the same + * 'ifdef' guard to avoid double definitions just in case. + */ +#ifndef _UAPI_LINUX_NVME_IOCTL_H +#define _UAPI_LINUX_NVME_IOCTL_H + +#ifndef _LINUX_NVME_IOCTL_H +#define _LINUX_NVME_IOCTL_H + +/** + * DOC: ioctl.h + * + * Linux NVMe ioctl interface functions + */ + +/* '0' is interpreted by the kernel to mean 'apply the default timeout' */ +#define NVME_DEFAULT_IOCTL_TIMEOUT 0 + +/** + * struct nvme_passthru_cmd - nvme passthrough command structure + * @opcode: Operation code, see &enum nvme_io_opcodes and &enum nvme_admin_opcodes + * @flags: Not supported: intended for command flags (eg: SGL, FUSE) + * @rsvd1: Reserved for future use + * @nsid: Namespace Identifier, or Fabrics type + * @cdw2: Command Dword 2 (no spec defined use) + * @cdw3: Command Dword 3 (no spec defined use) + * @metadata: User space address to metadata buffer (NULL if not used) + * @addr: User space address to data buffer (NULL if not used) + * @metadata_len: Metadata buffer transfer length + * @data_len: Data buffer transfer length + * @cdw10: Command Dword 10 (command specific) + * @cdw11: Command Dword 11 (command specific) + * @cdw12: Command Dword 12 (command specific) + * @cdw13: Command Dword 13 (command specific) + * @cdw14: Command Dword 14 (command specific) + * @cdw15: Command Dword 15 (command specific) + * @timeout_ms: If non-zero, overrides system default timeout in milliseconds + * @result: Set on completion to the command's CQE DWORD 0 controller response + */ +struct nvme_passthru_cmd { + __u8 opcode; + __u8 flags; + __u16 rsvd1; + __u32 nsid; + __u32 cdw2; + __u32 cdw3; + __u64 metadata; + __u64 addr; + __u32 metadata_len; + __u32 data_len; + __u32 cdw10; + __u32 cdw11; + __u32 cdw12; + __u32 cdw13; + __u32 cdw14; + __u32 cdw15; + __u32 timeout_ms; + __u32 result; +}; + +/** + * struct nvme_passthru_cmd64 - 64-bit nvme passthrough command structure + * @opcode: Operation code, see &enum nvme_io_opcodes and &enum nvme_admin_opcodes + * @flags: Not supported: intended for command flags (eg: SGL, FUSE) + * @rsvd1: Reserved for future use + * @nsid: Namespace Identifier, or Fabrics type + * @cdw2: Command Dword 2 (no spec defined use) + * @cdw3: Command Dword 3 (no spec defined use) + * @metadata: User space address to metadata buffer (NULL if not used) + * @addr: User space address to data buffer (NULL if not used) + * @metadata_len: Metadata buffer transfer length + * @data_len: Data buffer transfer length + * @cdw10: Command Dword 10 (command specific) + * @cdw11: Command Dword 11 (command specific) + * @cdw12: Command Dword 12 (command specific) + * @cdw13: Command Dword 13 (command specific) + * @cdw14: Command Dword 14 (command specific) + * @cdw15: Command Dword 15 (command specific) + * @timeout_ms: If non-zero, overrides system default timeout in milliseconds + * @rsvd2: Reserved for future use (and fills an impicit struct pad + * @result: Set on completion to the command's CQE DWORD 0-1 controller response + */ +struct nvme_passthru_cmd64 { + __u8 opcode; + __u8 flags; + __u16 rsvd1; + __u32 nsid; + __u32 cdw2; + __u32 cdw3; + __u64 metadata; + __u64 addr; + __u32 metadata_len; + __u32 data_len; + __u32 cdw10; + __u32 cdw11; + __u32 cdw12; + __u32 cdw13; + __u32 cdw14; + __u32 cdw15; + __u32 timeout_ms; + __u32 rsvd2; + __u64 result; +}; + +#define NVME_IOCTL_ID _IO('N', 0x40) +#define NVME_IOCTL_RESET _IO('N', 0x44) +#define NVME_IOCTL_SUBSYS_RESET _IO('N', 0x45) +#define NVME_IOCTL_RESCAN _IO('N', 0x46) +#define NVME_IOCTL_ADMIN_CMD _IOWR('N', 0x41, struct nvme_passthru_cmd) +#define NVME_IOCTL_IO_CMD _IOWR('N', 0x43, struct nvme_passthru_cmd) +#define NVME_IOCTL_ADMIN64_CMD _IOWR('N', 0x47, struct nvme_passthru_cmd64) +#define NVME_IOCTL_IO64_CMD _IOWR('N', 0x48, struct nvme_passthru_cmd64) + +#endif /* _UAPI_LINUX_NVME_IOCTL_H */ + +#endif /* _LINUX_NVME_IOCTL_H */ + +/** + * nvme_submit_admin_passthru64() - Submit a 64-bit nvme passthrough admin + * command + * @fd: File descriptor of nvme device + * @cmd: The nvme admin command to send + * @result: Optional field to return the result from the CQE DW0-1 + * + * Uses NVME_IOCTL_ADMIN64_CMD for the ioctl request. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_submit_admin_passthru64(int fd, struct nvme_passthru_cmd64 *cmd, + __u64 *result); + +/** + * nvme_admin_passthru64() - Submit a 64-bit nvme passthrough command + * @fd: File descriptor of nvme device + * @opcode: The nvme io command to send + * @flags: NVMe command flags (not used) + * @rsvd: Reserevd for future use + * @nsid: Namespace identifier + * @cdw2: Command dword 2 + * @cdw3: Command dword 3 + * @cdw10: Command dword 10 + * @cdw11: Command dword 11 + * @cdw12: Command dword 12 + * @cdw13: Command dword 13 + * @cdw14: Command dword 14 + * @cdw15: Command dword 15 + * @data_len: Length of the data transfered in this command in bytes + * @data: Pointer to user address of the data buffer + * @metadata_len:Length of metadata transfered in this command + * @metadata: Pointer to user address of the metadata buffer + * @timeout_ms: How long the kernel waits for the command to complete + * @result: Optional field to return the result from the CQE dword 0 + * + * Parameterized form of nvme_submit_admin_passthru64(). This sets up and + * submits a &struct nvme_passthru_cmd64. + * + * Known values for @opcode are defined in &enum nvme_admin_opcode. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_admin_passthru64(int fd, __u8 opcode, __u8 flags, __u16 rsvd, + __u32 nsid, __u32 cdw2, __u32 cdw3, __u32 cdw10, __u32 cdw11, + __u32 cdw12, __u32 cdw13, __u32 cdw14, __u32 cdw15, + __u32 data_len, void *data, __u32 metadata_len, void *metadata, + __u32 timeout_ms, __u64 *result); + +/** + * nvme_submit_admin_passthru() - Submit an nvme passthrough admin command + * @fd: File descriptor of nvme device + * @cmd: The nvme admin command to send + * @result: Optional field to return the result from the CQE DW0 + * + * Uses NVME_IOCTL_ADMIN_CMD for the ioctl request. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_submit_admin_passthru(int fd, struct nvme_passthru_cmd *cmd, + __u32 *result); + +/** + * nvme_admin_passthru() - Submit an nvme passthrough command + * @fd: File descriptor of nvme device + * @opcode: The nvme io command to send + * @flags: NVMe command flags (not used) + * @rsvd: Reserevd for future use + * @nsid: Namespace identifier + * @cdw2: Command dword 2 + * @cdw3: Command dword 3 + * @cdw10: Command dword 10 + * @cdw11: Command dword 11 + * @cdw12: Command dword 12 + * @cdw13: Command dword 13 + * @cdw14: Command dword 14 + * @cdw15: Command dword 15 + * @data_len: Length of the data transfered in this command in bytes + * @data: Pointer to user address of the data buffer + * @metadata_len:Length of metadata transfered in this command + * @metadata: Pointer to user address of the metadata buffer + * @timeout_ms: How long the kernel waits for the command to complete + * @result: Optional field to return the result from the CQE dword 0 + * + * Parameterized form of nvme_submit_admin_passthru(). This sets up and + * submits a &struct nvme_passthru_cmd. + * + * Known values for @opcode are defined in &enum nvme_admin_opcode. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_admin_passthru(int fd, __u8 opcode, __u8 flags, __u16 rsvd, + __u32 nsid, __u32 cdw2, __u32 cdw3, __u32 cdw10, __u32 cdw11, + __u32 cdw12, __u32 cdw13, __u32 cdw14, __u32 cdw15, + __u32 data_len, void *data, __u32 metadata_len, void *metadata, + __u32 timeout_ms, __u32 *result); + +/** + * nvme_submit_io_passthru64() - Submit a 64-bit nvme passthrough command + * @fd: File descriptor of nvme device + * @cmd: The nvme io command to send + * @result: Optional field to return the result from the CQE DW0-1 + * + * Uses NVME_IOCTL_IO64_CMD for the ioctl request. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_submit_io_passthru64(int fd, struct nvme_passthru_cmd64 *cmd, + __u64 *result); + +/** + * nvme_io_passthru64() - Submit an nvme io passthrough command + * @fd: File descriptor of nvme device + * @opcode: The nvme io command to send + * @flags: NVMe command flags (not used) + * @rsvd: Reserevd for future use + * @nsid: Namespace identifier + * @cdw2: Command dword 2 + * @cdw3: Command dword 3 + * @cdw10: Command dword 10 + * @cdw11: Command dword 11 + * @cdw12: Command dword 12 + * @cdw13: Command dword 13 + * @cdw14: Command dword 14 + * @cdw15: Command dword 15 + * @data_len: Length of the data transfered in this command in bytes + * @data: Pointer to user address of the data buffer + * @metadata_len:Length of metadata transfered in this command + * @metadata: Pointer to user address of the metadata buffer + * @timeout_ms: How long the kernel waits for the command to complete + * @result: Optional field to return the result from the CQE dword 0 + * + * Parameterized form of nvme_submit_io_passthru64(). This sets up and submits + * a &struct nvme_passthru_cmd64. + * + * Known values for @opcode are defined in &enum nvme_io_opcode. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_io_passthru64(int fd, __u8 opcode, __u8 flags, __u16 rsvd, + __u32 nsid, __u32 cdw2, __u32 cdw3, __u32 cdw10, __u32 cdw11, + __u32 cdw12, __u32 cdw13, __u32 cdw14, __u32 cdw15, + __u32 data_len, void *data, __u32 metadata_len, void *metadata, + __u32 timeout_ms, __u64 *result); + +/** + * nvme_submit_io_passthru() - Submit an nvme passthrough command + * @fd: File descriptor of nvme device + * @cmd: The nvme io command to send + * @result: Optional field to return the result from the CQE dword 0 + * @result: Optional field to return the result from the CQE DW0 + * + * Uses NVME_IOCTL_IO_CMD for the ioctl request. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_submit_io_passthru(int fd, struct nvme_passthru_cmd *cmd, + __u32 *result); + +/** + * nvme_io_passthru() - Submit an nvme io passthrough command + * @fd: File descriptor of nvme device + * @opcode: The nvme io command to send + * @flags: NVMe command flags (not used) + * @rsvd: Reserevd for future use + * @nsid: Namespace identifier + * @cdw2: Command dword 2 + * @cdw3: Command dword 3 + * @cdw10: Command dword 10 + * @cdw11: Command dword 11 + * @cdw12: Command dword 12 + * @cdw13: Command dword 13 + * @cdw14: Command dword 14 + * @cdw15: Command dword 15 + * @data_len: Length of the data transfered in this command in bytes + * @data: Pointer to user address of the data buffer + * @metadata_len:Length of metadata transfered in this command + * @metadata: Pointer to user address of the metadata buffer + * @timeout_ms: How long the kernel waits for the command to complete + * @result: Optional field to return the result from the CQE dword 0 + * + * Parameterized form of nvme_submit_io_passthru(). This sets up and submits + * a &struct nvme_passthru_cmd. + * + * Known values for @opcode are defined in &enum nvme_io_opcode. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_io_passthru(int fd, __u8 opcode, __u8 flags, __u16 rsvd, + __u32 nsid, __u32 cdw2, __u32 cdw3, __u32 cdw10, __u32 cdw11, + __u32 cdw12, __u32 cdw13, __u32 cdw14, __u32 cdw15, + __u32 data_len, void *data, __u32 metadata_len, void *metadata, + __u32 timeout_ms, __u32 *result); + +/** + * nvme_subsystem_reset() - Initiate a subsystem reset + * @fd: File descriptor of nvme device + * + * This should only be sent to controller handles, not to namespaces. + * + * Return: Zero if a subsystem reset was initiated or -1 with errno set + * otherwise. + */ +int nvme_subsystem_reset(int fd); + +/** + * nvme_ctrl_reset() - Initiate a controller reset + * @fd: File descriptor of nvme device + * + * This should only be sent to controller handles, not to namespaces. + * + * Return: 0 if a reset was initiated or -1 with errno set otherwise. + */ +int nvme_ctrl_reset(int fd); + +/** + * nvme_ns_rescan() - Initiate a controller rescan + * @fd: File descriptor of nvme device + * + * This should only be sent to controller handles, not to namespaces. + * + * Return: 0 if a rescan was initiated or -1 with errno set otherwise. + */ +int nvme_ns_rescan(int fd); + +/** + * nvme_get_nsid() - Retrieve the NSID from a namespace file descriptor + * @fd: File descriptor of nvme namespace + * @nsid: User pointer to namespace id + * + * This should only be sent to namespace handles, not to controllers. The + * kernel's interface returns the nsid as the return value. This is unfortunate + * for many architectures that are incapable of allowing distinguishing a + * namespace id > 0x80000000 from a negative error number. + * + * Return: 0 if @nsid was set successfully or -1 with errno set otherwise. + */ +int nvme_get_nsid(int fd, __u32 *nsid); + +/** + * struct nvme_identify_args - Arguments for the NVMe Identify command + * @result: The command completion result from CQE dword0 + * @data: User space destination address to transfer the data + * @args_size: Size of &struct nvme_identify_args + * @fd: File descriptor of nvme device + * @timeout: Timeout in ms (0 for default timeout) + * @cns: The Controller or Namespace structure, see @enum nvme_identify_cns + * @csi: Command Set Identifier + * @nsid: Namespace identifier, if applicable + * @cntid: The Controller Identifier, if applicable + * @cns_specific_id: Identifier that is required for a particular CNS value + * @uuidx: UUID Index if controller supports this id selection method + */ +struct nvme_identify_args { + __u32 *result; + void *data; + int args_size; + int fd; + __u32 timeout; + enum nvme_identify_cns cns; + enum nvme_csi csi; + __u32 nsid; + __u16 cntid; + __u16 cns_specific_id; + __u8 uuidx; +}; + +/** + * nvme_identify() - Send the NVMe Identify command + * @args: &struct nvme_identify_args argument structure + * + * The Identify command returns a data buffer that describes information about + * the NVM subsystem, the controller or the namespace(s). + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_identify(struct nvme_identify_args *args); + +static int nvme_identify_cns_nsid(int fd, enum nvme_identify_cns cns, + __u32 nsid, void *data) +{ + struct nvme_identify_args args = { + .result = NULL, + .data = data, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .cns = cns, + .csi = NVME_CSI_NVM, + .nsid = nsid, + .cntid = NVME_CNTLID_NONE, + .cns_specific_id = NVME_CNSSPECID_NONE, + .uuidx = NVME_UUID_NONE, + }; + + return nvme_identify(&args); +} + +/** + * nvme_identify_ctrl() - Retrieves nvme identify controller + * @fd: File descriptor of nvme device + * @id: User space destination address to transfer the data, + * + * Sends nvme identify with CNS value %NVME_IDENTIFY_CNS_CTRL. + * + * See &struct nvme_id_ctrl for details on the data returned. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_identify_ctrl(int fd, struct nvme_id_ctrl *id) +{ + return nvme_identify_cns_nsid(fd, NVME_IDENTIFY_CNS_CTRL, + NVME_NSID_NONE, id); +} + +/** + * nvme_identify_ns() - Retrieves nvme identify namespace + * @fd: File descriptor of nvme device + * @nsid: Namespace to identify + * @ns: User space destination address to transfer the data + * + * If the Namespace Identifier (NSID) field specifies an active NSID, then the + * Identify Namespace data structure is returned to the host for that specified + * namespace. + * + * If the controller supports the Namespace Management capability and the NSID + * field is set to %NVME_NSID_ALL, then the controller returns an Identify Namespace + * data structure that specifies capabilities that are common across namespaces + * for this controller. + * + * See &struct nvme_id_ns for details on the structure returned. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_identify_ns(int fd, __u32 nsid, struct nvme_id_ns *ns) +{ + return nvme_identify_cns_nsid(fd, NVME_IDENTIFY_CNS_NS, nsid, ns); +} + +/** + * nvme_identify_allocated_ns() - Same as nvme_identify_ns, but only for + * allocated namespaces + * @fd: File descriptor of nvme device + * @nsid: Namespace to identify + * @ns: User space destination address to transfer the data + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_identify_allocated_ns(int fd, __u32 nsid, + struct nvme_id_ns *ns) +{ + return nvme_identify_cns_nsid(fd, NVME_IDENTIFY_CNS_ALLOCATED_NS, + nsid, ns); +} + +/** + * nvme_identify_active_ns_list() - Retrieves active namespaces id list + * @fd: File descriptor of nvme device + * @nsid: Return namespaces greater than this identifer + * @list: User space destination address to transfer the data + * + * A list of 1024 namespace IDs is returned to the host containing NSIDs in + * increasing order that are greater than the value specified in the Namespace + * Identifier (nsid) field of the command. + * + * See &struct nvme_ns_list for the definition of the returned structure. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_identify_active_ns_list(int fd, __u32 nsid, + struct nvme_ns_list *list) +{ + return nvme_identify_cns_nsid(fd, NVME_IDENTIFY_CNS_NS_ACTIVE_LIST, + nsid, list); +} + +/** + * nvme_identify_allocated_ns_list() - Retrieves allocated namespace id list + * @fd: File descriptor of nvme device + * @nsid: Return namespaces greater than this identifer + * @list: User space destination address to transfer the data + * + * A list of 1024 namespace IDs is returned to the host containing NSIDs in + * increasing order that are greater than the value specified in the Namespace + * Identifier (nsid) field of the command. + * + * See &struct nvme_ns_list for the definition of the returned structure. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_identify_allocated_ns_list(int fd, __u32 nsid, + struct nvme_ns_list *list) +{ + return nvme_identify_cns_nsid(fd, NVME_IDENTIFY_CNS_ALLOCATED_NS_LIST, + nsid, list); +} + +/** + * nvme_identify_ctrl_list() - Retrieves identify controller list + * @fd: File descriptor of nvme device + * @cntid: Starting CNTLID to return in the list + * @cntlist: User space destination address to transfer the data + * + * Up to 2047 controller identifiers is returned containing a controller + * identifier greater than or equal to the controller identifier specified in + * @cntid. + * + * See &struct nvme_ctrl_list for a definition of the structure returned. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_identify_ctrl_list(int fd, __u16 cntid, + struct nvme_ctrl_list *cntlist) +{ + struct nvme_identify_args args = { + .result = NULL, + .data = cntlist, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .cns = NVME_IDENTIFY_CNS_CTRL_LIST, + .csi = NVME_CSI_NVM, + .nsid = NVME_NSID_NONE, + .cntid = cntid, + .cns_specific_id = NVME_CNSSPECID_NONE, + .uuidx = NVME_UUID_NONE, + }; + + return nvme_identify(&args); +} + +/** + * nvme_identify_nsid_ctrl_list() - Retrieves controller list attached to an nsid + * @fd: File descriptor of nvme device + * @nsid: Return controllers that are attached to this nsid + * @cntid: Starting CNTLID to return in the list + * @cntlist: User space destination address to transfer the data + * + * Up to 2047 controller identifiers are returned containing a controller + * identifier greater than or equal to the controller identifier specified in + * @cntid attached to @nsid. + * + * See &struct nvme_ctrl_list for a definition of the structure returned. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 + */ +static inline int nvme_identify_nsid_ctrl_list(int fd, __u32 nsid, __u16 cntid, + struct nvme_ctrl_list *cntlist) +{ + struct nvme_identify_args args = { + .result = NULL, + .data = cntlist, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .cns = NVME_IDENTIFY_CNS_NS_CTRL_LIST, + .csi = NVME_CSI_NVM, + .nsid = nsid, + .cntid = cntid, + .cns_specific_id = NVME_CNSSPECID_NONE, + .uuidx = NVME_UUID_NONE, + }; + + return nvme_identify(&args); +} + +/** + * nvme_identify_ns_descs() - Retrieves namespace descriptor list + * @fd: File descriptor of nvme device + * @nsid: The namespace id to retrieve destriptors + * @descs: User space destination address to transfer the data + * + * A list of Namespace Identification Descriptor structures is returned to the + * host for the namespace specified in the Namespace Identifier (NSID) field if + * it is an active NSID. + * + * The data returned is in the form of an arrray of 'struct nvme_ns_id_desc'. + * + * See &struct nvme_ns_id_desc for the definition of the returned structure. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_identify_ns_descs(int fd, __u32 nsid, + struct nvme_ns_id_desc *descs) +{ + return nvme_identify_cns_nsid(fd, NVME_IDENTIFY_CNS_NS_DESC_LIST, + nsid, descs); +} + +/** + * nvme_identify_nvmset_list() - Retrieves NVM Set List + * @fd: File descriptor of nvme device + * @nvmsetid: NVM Set Identifier + * @nvmset: User space destination address to transfer the data + * + * Retrieves an NVM Set List, &struct nvme_id_nvmset_list. The data structure + * is an ordered list by NVM Set Identifier, starting with the first NVM Set + * Identifier supported by the NVM subsystem that is equal to or greater than + * the NVM Set Identifier. + * + * See &struct nvme_id_nvmset_list for the defintion of the returned structure. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_identify_nvmset_list(int fd, __u16 nvmsetid, + struct nvme_id_nvmset_list *nvmset) +{ + struct nvme_identify_args args = { + .result = NULL, + .data = nvmset, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .cns = NVME_IDENTIFY_CNS_NVMSET_LIST, + .csi = NVME_CSI_NVM, + .nsid = NVME_NSID_NONE, + .cntid = NVME_CNTLID_NONE, + .cns_specific_id = nvmsetid, + .uuidx = NVME_UUID_NONE, + }; + + return nvme_identify(&args); +} + +/** + * nvme_identify_primary_ctrl() - Retrieve NVMe Primary Controller + * identification + * @fd: File descriptor of nvme device + * @cntid: Return controllers starting at this identifier + * @cap: User space destination buffer address to transfer the data + * + * See &struct nvme_primary_ctrl_cap for the defintion of the returned structure, @cap. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_identify_primary_ctrl(int fd, __u16 cntid, + struct nvme_primary_ctrl_cap *cap) +{ + struct nvme_identify_args args = { + .result = NULL, + .data = cap, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .cns = NVME_IDENTIFY_CNS_PRIMARY_CTRL_CAP, + .csi = NVME_CSI_NVM, + .nsid = NVME_NSID_NONE, + .cntid = cntid, + .cns_specific_id = NVME_CNSSPECID_NONE, + .uuidx = NVME_UUID_NONE, + }; + + return nvme_identify(&args); +} + +/** + * nvme_identify_secondary_ctrl_list() - Retrieves secondary controller list + * @fd: File descriptor of nvme device + * @nsid: Namespace identifier + * @cntid: Return controllers starting at this identifier + * @sc_list: User space destination address to transfer the data + * + * A Secondary Controller List is returned to the host for up to 127 secondary + * controllers associated with the primary controller processing this command. + * The list contains entries for controller identifiers greater than or equal + * to the value specified in the Controller Identifier (cntid). + * + * See &struct nvme_secondary_ctrls_list for a defintion of the returned + * structure. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_identify_secondary_ctrl_list(int fd, __u32 nsid, + __u16 cntid, struct nvme_secondary_ctrl_list *sc_list) +{ + struct nvme_identify_args args = { + .result = NULL, + .data = sc_list, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .cns = NVME_IDENTIFY_CNS_SECONDARY_CTRL_LIST, + .csi = NVME_CSI_NVM, + .nsid = nsid, + .cntid = cntid, + .cns_specific_id = NVME_CNSSPECID_NONE, + .uuidx = NVME_UUID_NONE, + }; + + return nvme_identify(&args); +} + +/** + * nvme_identify_ns_granularity() - Retrieves namespace granularity + * identification + * @fd: File descriptor of nvme device + * @gr_list: User space destination address to transfer the data + * + * If the controller supports reporting of Namespace Granularity, then a + * Namespace Granularity List is returned to the host for up to sixteen + * namespace granularity descriptors + * + * See &struct nvme_id_ns_granularity_list for the definition of the returned + * structure. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_identify_ns_granularity(int fd, + struct nvme_id_ns_granularity_list *gr_list) +{ + return nvme_identify_cns_nsid(fd, NVME_IDENTIFY_CNS_NS_GRANULARITY, + NVME_NSID_NONE, gr_list); +} + +/** + * nvme_identify_uuid() - Retrieves device's UUIDs + * @fd: File descriptor of nvme device + * @uuid_list: User space destination address to transfer the data + * + * Each UUID List entry is either 0h, the NVMe Invalid UUID, or a valid UUID. + * Valid UUIDs are those which are non-zero and are not the NVMe Invalid UUID. + * + * See &struct nvme_id_uuid_list for the definition of the returned structure. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_identify_uuid(int fd, struct nvme_id_uuid_list *uuid_list) +{ + return nvme_identify_cns_nsid(fd, NVME_IDENTIFY_CNS_UUID_LIST, + NVME_NSID_NONE, uuid_list); +} + +/** + * nvme_identify_ns_csi() - I/O command set specific identify namespace data + * @fd: File descriptor of nvme device + * @nsid: Namespace to identify + * @uuidx: UUID Index for differentiating vendor specific encoding + * @csi: Command Set Identifier + * @data: User space destination address to transfer the data + * + * An I/O Command Set specific Identify Namespace data structre is returned + * for the namespace specified in @nsid. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_identify_ns_csi(int fd, __u32 nsid, __u8 uuidx, + enum nvme_csi csi, void *data) +{ + struct nvme_identify_args args = { + .result = NULL, + .data = data, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .cns = NVME_IDENTIFY_CNS_CSI_NS, + .csi = csi, + .nsid = nsid, + .cntid = NVME_CNTLID_NONE, + .cns_specific_id = NVME_CNSSPECID_NONE, + .uuidx = uuidx, + }; + + return nvme_identify(&args); +} + +/** + * nvme_identify_ctrl_csi() - I/O command set specific Identify Controller data + * @fd: File descriptor of nvme device + * @csi: Command Set Identifier + * @data: User space destination address to transfer the data + * + * An I/O Command Set specific Identify Controller data structure is returned + * to the host for the controller processing the command. The specific Identify + * Controller data structure to be returned is specified by @csi. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_identify_ctrl_csi(int fd, enum nvme_csi csi, void *data) +{ + struct nvme_identify_args args = { + .result = NULL, + .data = data, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .cns = NVME_IDENTIFY_CNS_CSI_CTRL, + .csi = csi, + .nsid = NVME_NSID_NONE, + .cntid = NVME_CNTLID_NONE, + .cns_specific_id = NVME_CNSSPECID_NONE, + .uuidx = NVME_UUID_NONE, + }; + + return nvme_identify(&args); +} + +/** + * nvme_identify_active_ns_list_csi() - Active namespace ID list associated with a specified I/O command set + * @fd: File descriptor of nvme device + * @nsid: Return namespaces greater than this identifier + * @csi: Command Set Identifier + * @ns_list: User space destination address to transfer the data + * + * A list of 1024 namespace IDs is returned to the host containing active + * NSIDs in increasing order that are greater than the value specified in + * the Namespace Identifier (nsid) field of the command and matching the + * I/O Command Set specified in the @csi argument. + * + * See &struct nvme_ns_list for the definition of the returned structure. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_identify_active_ns_list_csi(int fd, __u32 nsid, + enum nvme_csi csi, struct nvme_ns_list *ns_list) +{ + struct nvme_identify_args args = { + .result = NULL, + .data = ns_list, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .cns = NVME_IDENTIFY_CNS_CSI_NS_ACTIVE_LIST, + .csi = csi, + .nsid = nsid, + .cntid = NVME_CNTLID_NONE, + .cns_specific_id = NVME_CNSSPECID_NONE, + .uuidx = NVME_UUID_NONE, + }; + + return nvme_identify(&args); +} + +/** + * nvme_identify_allocated_ns_list_csi() - Allocated namespace ID list associated with a specified I/O command set + * @fd: File descriptor of nvme device + * @nsid: Return namespaces greater than this identifier + * @csi: Command Set Identifier + * @ns_list: User space destination address to transfer the data + * + * A list of 1024 namespace IDs is returned to the host containing allocated + * NSIDs in increasing order that are greater than the value specified in + * the @nsid field of the command and matching the I/O Command Set + * specified in the @csi argument. + * + * See &struct nvme_ns_list for the definition of the returned structure. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_identify_allocated_ns_list_csi(int fd, __u32 nsid, + enum nvme_csi csi, struct nvme_ns_list *ns_list) +{ + struct nvme_identify_args args = { + .result = NULL, + .data = ns_list, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .cns = NVME_IDENTIFY_CNS_CSI_ALLOCATED_NS_LIST, + .csi = csi, + .nsid = nsid, + .cntid = NVME_CNTLID_NONE, + .cns_specific_id = NVME_CNSSPECID_NONE, + .uuidx = NVME_UUID_NONE, + }; + + return nvme_identify(&args); +} + +/** + * nvme_identify_independent_identify_ns() - I/O command set independent Identify namespace data + * @fd: File descriptor of nvme device + * @nsid: Return namespaces greater than this identifier + * @ns: I/O Command Set Independent Identify Namespace data + * structure + * + * The I/O command set independent Identify namespace data structure for + * the namespace identified with @ns is returned to the host. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_identify_independent_identify_ns(int fd, __u32 nsid, + struct nvme_id_independent_id_ns *ns) +{ + struct nvme_identify_args args = { + .result = NULL, + .data = ns, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .cns = NVME_IDENTIFY_CNS_CSI_INDEPENDENT_ID_NS, + .csi = NVME_CSI_NVM, + .nsid = nsid, + .cntid = NVME_CNTLID_NONE, + .cns_specific_id = NVME_CNSSPECID_NONE, + .uuidx = NVME_UUID_NONE, + }; + + return nvme_identify(&args); +} + +/** + * nvme_identify_ns_csi_user_data_format() - + * @fd: File descriptor of nvme device + * @user_data_format: Return namespaces capability of identifier + * @uuidx: UUID selection, if supported + * @csi: Command Set Identifier + * + * Identify Namespace data structure for the specified User Data Format + * index containing the namespace capabilities for the NVM Command Set. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_identify_ns_csi_user_data_format(int fd, + __u16 user_data_format, __u8 uuidx, + enum nvme_csi csi, void *data) +{ + struct nvme_identify_args args = { + .result = NULL, + .data = data, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .cns = NVME_IDENTIFY_CNS_NS_USER_DATA_FORMAT, + .csi = csi, + .nsid = NVME_NSID_NONE, + .cntid = NVME_CNTLID_NONE, + .cns_specific_id = user_data_format, + .uuidx = uuidx, + }; + + return nvme_identify(&args); +} + +/** + * nvme_identify_iocs_ns_csi_user_data_format() - + * @fd: File descriptor of nvme device + * @user_data_format: Return namespaces capability of identifier + * @uuidx: UUID selection, if supported + * @csi: Command Set Identifier + * + * I/O Command Set specific Identify Namespace data structure for + * the specified User Data Format index containing the namespace + * capabilities for the I/O Command Set specified in the CSI field. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_identify_iocs_ns_csi_user_data_format(int fd, + __u16 user_data_format, __u8 uuidx, + enum nvme_csi csi, void *data) +{ + struct nvme_identify_args args = { + .result = NULL, + .data = data, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .cns = NVME_IDENTIFY_CNS_CSI_NS_USER_DATA_FORMAT, + .csi = csi, + .nsid = NVME_NSID_NONE, + .cntid = NVME_CNTLID_NONE, + .cns_specific_id = user_data_format, + .uuidx = uuidx, + }; + + return nvme_identify(&args); +} + +/** + * nvme_nvm_identify_ctrl() - Identify controller data + * @fd: File descriptor of nvme device + * @id: User space destination address to transfer the data + * + * Return an identify controller data structure to the host of + * processing controller. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_nvm_identify_ctrl(int fd, struct nvme_id_ctrl_nvm *id) +{ + return nvme_identify_ctrl_csi(fd, NVME_CSI_NVM, id); +} + +/** + * nvme_identify_domain_list() - Domain list data + * @fd: File descriptor of nvme device + * @domid: Domain ID + * @list: User space destiantion address to transfer data + * + * A list of 31 domain IDs is returned to the host containing domain + * attributes in increasing order that are greater than the value + * specified in the @domid field. + * + * See &struct nvme_identify_domain_attr for the definition of the + * returned structure. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_identify_domain_list(int fd, __u16 domid, + struct nvme_id_domain_list *list) +{ + struct nvme_identify_args args = { + .result = NULL, + .data = list, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .cns = NVME_IDENTIFY_CNS_DOMAIN_LIST, + .csi = NVME_CSI_NVM, + .nsid = NVME_NSID_NONE, + .cntid = NVME_CNTLID_NONE, + .cns_specific_id = domid, + .uuidx = NVME_UUID_NONE, + }; + + return nvme_identify(&args); +} + +/** + * nvme_identify_endurance_group_list() - Endurance group list data + * @fd: File descriptor of nvme device + * @endgrp_id: Endurance group identifier + * @list: Array of endurance group identifiers + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_identify_endurance_group_list(int fd, __u16 endgrp_id, + struct nvme_id_endurance_group_list *list) +{ + struct nvme_identify_args args = { + .result = NULL, + .data = list, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .cns = NVME_IDENTIFY_CNS_ENDURANCE_GROUP_ID, + .csi = NVME_CSI_NVM, + .nsid = NVME_NSID_NONE, + .cntid = NVME_CNTLID_NONE, + .cns_specific_id = endgrp_id, + .uuidx = NVME_UUID_NONE, + }; + + return nvme_identify(&args); +} + +/** + * nvme_identify_iocs() - I/O command set data structure + * @fd: File descriptor of nvme device + * @cntlid: Controller ID + * @iocs: User space destination address to transfer the data + * + * Retrieves list of the controller's supported io command set vectors. See + * &struct nvme_id_iocs. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_identify_iocs(int fd, __u16 cntlid, + struct nvme_id_iocs *iocs) +{ + struct nvme_identify_args args = { + .result = NULL, + .data = iocs, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .cns = NVME_IDENTIFY_CNS_COMMAND_SET_STRUCTURE, + .csi = NVME_CSI_NVM, + .nsid = NVME_NSID_NONE, + .cntid = cntlid, + .cns_specific_id = NVME_CNSSPECID_NONE, + .uuidx = NVME_UUID_NONE, + }; + + return nvme_identify(&args); +} + +/** + * nvme_zns_identify_ns() - ZNS identify namespace data + * @fd: File descriptor of nvme device + * @nsid: Namespace to identify + * @data: User space destination address to transfer the data + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_zns_identify_ns(int fd, __u32 nsid, + struct nvme_zns_id_ns *data) +{ + struct nvme_identify_args args = { + .result = NULL, + .data = data, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .cns = NVME_IDENTIFY_CNS_CSI_NS, + .csi = NVME_CSI_ZNS, + .nsid = nsid, + .cntid = NVME_CNTLID_NONE, + .cns_specific_id = NVME_CNSSPECID_NONE, + }; + + return nvme_identify(&args); +} + +/** + * nvme_zns_identify_ctrl() - ZNS identify controller data + * @fd: File descriptor of nvme device + * @id: User space destination address to transfer the data + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_zns_identify_ctrl(int fd, struct nvme_zns_id_ctrl *id) +{ + return nvme_identify_ctrl_csi(fd, NVME_CSI_ZNS, id); +} + +/** + * struct nvme_get_log_args - Arguments for the NVMe Admin Get Log command + * @lpo: Log page offset for partial log transfers + * @result: The command completion result from CQE dword0 + * @log: User space destination address to transfer the data + * @args_size: Length of the structure + * @fd: File descriptor of nvme device + * @timeout: Timeout in ms + * @lid: Log page identifier, see &enum nvme_cmd_get_log_lid for known + * values + * @len: Length of provided user buffer to hold the log data in bytes + * @nsid: Namespace identifier, if applicable + * @csi: Command set identifier, see &enum nvme_csi for known values + * @lsi: Log Specific Identifier + * @lsp: Log specific field + * @uuidx: UUID selection, if supported + * @rae: Retain asynchronous events + * @ot: Offset Type; if set @lpo specifies the index into the list + * of data structures, otherwise @lpo specifies the byte offset + * into the log page. + */ +struct nvme_get_log_args { + __u64 lpo; + __u32 *result; + void *log; + int args_size; + int fd; + __u32 timeout; + enum nvme_cmd_get_log_lid lid; + __u32 len; + __u32 nsid; + enum nvme_csi csi; + __u16 lsi; + __u8 lsp; + __u8 uuidx; + bool rae; + bool ot; +}; + +/** + * nvme_get_log() - NVMe Admin Get Log command + * @args: &struct nvme_get_log_args argument structure + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_log(struct nvme_get_log_args *args); + +static inline int nvme_get_nsid_log(int fd, bool rae, + enum nvme_cmd_get_log_lid lid, + __u32 nsid, __u32 len, void *log) +{ + struct nvme_get_log_args args = { + .lpo = 0, + .result = NULL, + .log = log, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .lid = lid, + .len = len, + .nsid = nsid, + .csi = NVME_CSI_NVM, + .lsi = NVME_LOG_LSI_NONE, + .lsp = NVME_LOG_LSP_NONE, + .uuidx = NVME_UUID_NONE, + .rae = false, + .ot = false, + }; + + return nvme_get_log(&args); +} + +static inline int nvme_get_log_simple(int fd, enum nvme_cmd_get_log_lid lid, + __u32 len, void *log) +{ + return nvme_get_nsid_log(fd, false, lid, NVME_NSID_ALL, len, log); +} + +/** + * nvme_get_log_supported_log_pages() - Retrieve nmve supported log pages + * @fd: File descriptor of nvme device + * @rae: Retain asynchronous events + * @log: Array of LID supported and Effects data structures + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_get_log_supported_log_pages(int fd, bool rae, + struct nvme_supported_log_pages *log) +{ + return nvme_get_nsid_log(fd, rae, NVME_LOG_LID_SUPPORTED_LOG_PAGES, + NVME_NSID_ALL, sizeof(*log), log); +} + +/** + * nvme_get_log_error() - Retrieve nvme error log + * @fd: File descriptor of nvme device + * @nr_entries: Number of error log entries allocated + * @rae: Retain asynchronous events + * @err_log: Array of error logs of size 'entries' + * + * This log page describes extended error information for a command that + * completed with error, or may report an error that is not specific to a + * particular command. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_get_log_error(int fd, unsigned nr_entries, bool rae, + struct nvme_error_log_page *err_log) +{ + return nvme_get_nsid_log(fd, rae, NVME_LOG_LID_ERROR, + NVME_NSID_ALL, sizeof(*err_log) * nr_entries, + err_log); +} + +/** + * nvme_get_log_smart() - Retrieve nvme smart log + * @fd: File descriptor of nvme device + * @nsid: Optional namespace identifier + * @rae: Retain asynchronous events + * @smart_log: User address to store the smart log + * + * This log page provides SMART and general health information. The information + * provided is over the life of the controller and is retained across power + * cycles. To request the controller log page, the namespace identifier + * specified is FFFFFFFFh. The controller may also support requesting the log + * page on a per namespace basis, as indicated by bit 0 of the LPA field in the + * Identify Controller data structure. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_get_log_smart(int fd, __u32 nsid, bool rae, + struct nvme_smart_log *smart_log) +{ + return nvme_get_nsid_log(fd, rae, NVME_LOG_LID_SMART, + nsid, sizeof(*smart_log), smart_log); +} + +/** + * nvme_get_log_fw_slot() - Retrieves the controller firmware log + * @fd: File descriptor of nvme device + * @rae: Retain asynchronous events + * @fw_log: User address to store the log page + * + * This log page describes the firmware revision stored in each firmware slot + * supported. The firmware revision is indicated as an ASCII string. The log + * page also indicates the active slot number. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_get_log_fw_slot(int fd, bool rae, + struct nvme_firmware_slot *fw_log) +{ + return nvme_get_nsid_log(fd, rae, NVME_LOG_LID_FW_SLOT, + NVME_NSID_ALL, sizeof(*fw_log), fw_log); +} + +/** + * nvme_get_log_changed_ns_list() - Retrieve namespace changed list + * @fd: File descriptor of nvme device + * @rae: Retain asynchronous events + * @ns_log: User address to store the log page + * + * This log page describes namespaces attached to this controller that have + * changed since the last time the namespace was identified, been added, or + * deleted. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_get_log_changed_ns_list(int fd, bool rae, + struct nvme_ns_list *ns_log) +{ + return nvme_get_nsid_log(fd, rae, NVME_LOG_LID_CHANGED_NS, + NVME_NSID_ALL, sizeof(*ns_log), ns_log); +} + +/** + * nvme_get_log_cmd_effects() - Retrieve nvme command effects log + * @fd: File descriptor of nvme device + * @csi: Command Set Identifier + * @effects_log:User address to store the effects log + * + * This log page describes the commands that the controller supports and the + * effects of those commands on the state of the NVM subsystem. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_get_log_cmd_effects(int fd, enum nvme_csi csi, + struct nvme_cmd_effects_log *effects_log) +{ + struct nvme_get_log_args args = { + .lpo = 0, + .result = NULL, + .log = effects_log, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .lid = NVME_LOG_LID_CMD_EFFECTS, + .len = sizeof(*effects_log), + .nsid = NVME_NSID_ALL, + .csi = csi, + .lsi = NVME_LOG_LSI_NONE, + .lsp = NVME_LOG_LSP_NONE, + .uuidx = NVME_UUID_NONE, + .rae = false, + .ot = false, + }; + return nvme_get_log(&args); +} + +/** + * nvme_get_log_device_self_test() - Retrieve the device self test log + * @fd: File descriptor of nvme device + * @log: Userspace address of the log payload + * + * The log page indicates the status of an in progress self test and the + * percent complete of that operation, and the results of the previous 20 + * self-test operations. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_get_log_device_self_test(int fd, + struct nvme_self_test_log *log) +{ + return nvme_get_nsid_log(fd, false, NVME_LOG_LID_DEVICE_SELF_TEST, + NVME_NSID_ALL, sizeof(*log), log); +} + +/** + * nvme_get_log_create_telemetry_host() - Create host telemetry log + * @fd: File descriptor of nvme device + * @log: Userspace address of the log payload + */ +static inline int nvme_get_log_create_telemetry_host(int fd, + struct nvme_telemetry_log *log) +{ + struct nvme_get_log_args args = { + .lpo = 0, + .result = NULL, + .log = log, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .lid = NVME_LOG_LID_TELEMETRY_HOST, + .len = sizeof(*log), + .nsid = NVME_NSID_NONE, + .csi = NVME_CSI_NVM, + .lsi = NVME_LOG_LSI_NONE, + .lsp = NVME_LOG_TELEM_HOST_LSP_CREATE, + .uuidx = NVME_UUID_NONE, + .rae = false, + .ot = false, + }; + return nvme_get_log(&args); +} + +/** + * nvme_get_log_telemetry_host() - + * @fd: File descriptor of nvme device + * @offset: Offset into the telemetry data + * @len: Length of provided user buffer to hold the log data in bytes + * @log: User address for log page data + * + * Retreives the Telemetry Host-Initiated log page at the requested offset + * using the previously existing capture. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_get_log_telemetry_host(int fd, __u64 offset, + __u32 len, void *log) +{ + struct nvme_get_log_args args = { + .lpo = 0, + .result = NULL, + .log = log, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .lid = NVME_LOG_LID_TELEMETRY_HOST, + .len = len, + .nsid = NVME_NSID_NONE, + .csi = NVME_CSI_NVM, + .lsi = NVME_LOG_LSI_NONE, + .lsp = NVME_LOG_TELEM_HOST_LSP_RETAIN, + .uuidx = NVME_UUID_NONE, + .rae = false, + .ot = false, + }; + return nvme_get_log(&args); +} + +/** + * nvme_get_log_telemetry_ctrl() - + * @fd: File descriptor of nvme device + * @rae: Retain asynchronous events + * @offset: Offset into the telemetry data + * @len: Length of provided user buffer to hold the log data in bytes + * @log: User address for log page data + */ +static inline int nvme_get_log_telemetry_ctrl(int fd, bool rae, + __u64 offset, __u32 len, void *log) +{ + struct nvme_get_log_args args = { + .lpo = offset, + .result = NULL, + .log = log, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .lid = NVME_LOG_LID_TELEMETRY_CTRL, + .len = len, + .nsid = NVME_NSID_NONE, + .csi = NVME_CSI_NVM, + .lsi = NVME_LOG_LSI_NONE, + .lsp = NVME_LOG_LSP_NONE, + .uuidx = NVME_UUID_NONE, + .rae = rae, + .ot = false, + }; + return nvme_get_log(&args); +} + +/** + * nvme_get_log_endurance_group() - + * @fd: File descriptor of nvme device + * @endgid: Starting group identifier to return in the list + * @log: User address to store the endurance log + * + * This log page indicates if an Endurance Group Event has occurred for a + * particular Endurance Group. If an Endurance Group Event has occurred, the + * details of the particular event are included in the Endurance Group + * Information log page for that Endurance Group. An asynchronous event is + * generated when an entry for an Endurance Group is newly added to this log + * page. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_get_log_endurance_group(int fd, __u16 endgid, + struct nvme_endurance_group_log *log) +{ + struct nvme_get_log_args args = { + .lpo = 0, + .result = NULL, + .log = log, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .lid = NVME_LOG_LID_ENDURANCE_GROUP, + .len = sizeof(*log), + .nsid = NVME_NSID_NONE, + .csi = NVME_CSI_NVM, + .lsi = endgid, + .lsp = NVME_LOG_LSP_NONE, + .uuidx = NVME_UUID_NONE, + .rae = false, + .ot = false, + }; + return nvme_get_log(&args); +} + +/** + * nvme_get_log_predictable_lat_nvmset() - + * @fd: File descriptor of nvme device + * @nvmsetid: NVM set id + * @log: User address to store the predictable latency log + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_get_log_predictable_lat_nvmset(int fd, __u16 nvmsetid, + struct nvme_nvmset_predictable_lat_log *log) +{ + struct nvme_get_log_args args = { + .lpo = 0, + .result = NULL, + .log = log, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .lid = NVME_LOG_LID_PREDICTABLE_LAT_NVMSET, + .len = sizeof(*log), + .nsid = NVME_NSID_NONE, + .csi = NVME_CSI_NVM, + .lsi = nvmsetid, + .lsp = NVME_LOG_LSP_NONE, + .uuidx = NVME_UUID_NONE, + .rae = false, + .ot = false, + }; + return nvme_get_log(&args); +} + +/** + * nvme_get_log_predictable_lat_event() - + * @fd: File descriptor of nvme device + * @rae: Retain asynchronous events + * @offset: Offset into the predictable latency event + * @len: Length of provided user buffer to hold the log data in bytes + * @log: User address for log page data + */ +static inline int nvme_get_log_predictable_lat_event(int fd, bool rae, + __u32 offset, __u32 len, void *log) +{ + struct nvme_get_log_args args = { + .lpo = offset, + .result = NULL, + .log = log, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .lid = NVME_LOG_LID_PREDICTABLE_LAT_AGG, + .len = len, + .nsid = NVME_NSID_NONE, + .csi = NVME_CSI_NVM, + .lsi = NVME_LOG_LSI_NONE, + .lsp = NVME_LOG_LSP_NONE, + .uuidx = NVME_UUID_NONE, + .rae = rae, + .ot = false, + }; + return nvme_get_log(&args); +} + +/** + * nvme_get_log_ana() - + * @fd: File descriptor of nvme device + * @lsp: Log specific, see &enum nvme_get_log_ana_lsp + * @rae: Retain asynchronous events + * @offset: Offset to the start of the log page + * @len: The allocated length of the log page + * @log: User address to store the ana log + * + * This log consists of a header describing the log and descriptors containing + * the asymmetric namespace access information for ANA Groups that contain + * namespaces that are attached to the controller processing the command. + * + * See &struct nvme_ana_rsp_hdr for the defintion of the returned structure. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static int nvme_get_log_ana(int fd, enum nvme_log_ana_lsp lsp, bool rae, + __u64 offset, __u32 len, void *log) +{ + struct nvme_get_log_args args = { + .lpo = offset, + .result = NULL, + .log = log, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .lid = NVME_LOG_LID_ANA, + .len = len, + .nsid = NVME_NSID_NONE, + .csi = NVME_CSI_NVM, + .lsi = NVME_LOG_LSI_NONE, + .lsp = lsp, + .uuidx = NVME_UUID_NONE, + .rae = false, + .ot = false, + }; + return nvme_get_log(&args); +} + +/** + * nvme_get_log_ana_groups() - + * @fd: File descriptor of nvme device + * @rae: Retain asynchronous events + * @len: The allocated length of the log page + * @log: User address to store the ana group log + * + * See &struct nvme_ana_group_desc for the defintion of the returned structure. + */ +static inline int nvme_get_log_ana_groups(int fd, bool rae, __u32 len, + struct nvme_ana_group_desc *log) +{ + return nvme_get_log_ana(fd, NVME_LOG_ANA_LSP_RGO_GROUPS_ONLY, rae, 0, + len, log); +} + +/** + * nvme_get_log_lba_status() - + * @fd: File descriptor of nvme device + * @rae: Retain asynchronous events + * @offset: Offset to the start of the log page + * @len: The allocated length of the log page + * @log: User address to store the log page + */ +static inline int nvme_get_log_lba_status(int fd, bool rae, + __u64 offset, __u32 len, void *log) +{ + struct nvme_get_log_args args = { + .lpo = offset, + .result = NULL, + .log = log, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .lid = NVME_LOG_LID_LBA_STATUS, + .len = len, + .nsid = NVME_NSID_NONE, + .csi = NVME_CSI_NVM, + .lsi = NVME_LOG_LSI_NONE, + .lsp = NVME_LOG_LSP_NONE, + .uuidx = NVME_UUID_NONE, + .rae = rae, + .ot = false, + }; + return nvme_get_log(&args); +} + +/** + * nvme_get_log_endurance_grp_evt() - + * @fd: File descriptor of nvme device + * @rae: Retain asynchronous events + * @offset: Offset to the start of the log page + * @len: The allocated length of the log page + * @log: User address to store the log page + */ +static inline int nvme_get_log_endurance_grp_evt(int fd, bool rae, + __u32 offset, __u32 len, void *log) +{ + struct nvme_get_log_args args = { + .lpo = offset, + .result = NULL, + .log = log, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .lid = NVME_LOG_LID_ENDURANCE_GRP_EVT, + .len = len, + .nsid = NVME_NSID_NONE, + .csi = NVME_CSI_NVM, + .lsi = NVME_LOG_LSI_NONE, + .lsp = NVME_LOG_LSP_NONE, + .uuidx = NVME_UUID_NONE, + .rae = rae, + .ot = false, + }; + return nvme_get_log(&args); +} + +/** + * nvme_get_log_fid_supported_effects() - + * @fd: File descriptor of nvme device + * @rae: Retain asynchronous events + * @log: FID Supported and Effects data structure + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise + */ +static inline int nvme_get_log_fid_supported_effects(int fd, bool rae, + struct nvme_fid_supported_effects_log *log) +{ + return nvme_get_nsid_log(fd, rae, NVME_LOG_LID_FID_SUPPORTED_EFFECTS, + NVME_NSID_NONE, sizeof(*log), log); +} + +/** + * nvme_get_log_mi_cmd_supported_effects() - displays the MI Commands Supported byt the controller + * @fd: File descriptor of nvme device + * @rae: Retain asynchronous events + * @log: MI Command Supported and Effects data structure + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise + */ +static inline int nvme_get_log_mi_cmd_supported_effects(int fd, bool rae, + struct nvme_mi_cmd_supported_effects_log *log) +{ + return nvme_get_nsid_log(fd, rae, NVME_LOG_LID_MI_CMD_SUPPORTED_EFFECTS, + NVME_NSID_NONE, sizeof(*log), log); +} + +/** + * nvme_get_log_boot_partition() - + * @fd: File descriptor of nvme device + * @rae: Retain asynchronous events + * @lsp: The log specified field of LID + * @len: The allocated size, minimum + * struct nvme_boot_partition + * @part: User address to store the log page + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise + */ +static inline int nvme_get_log_boot_partition(int fd, bool rae, + __u8 lsp, __u32 len, struct nvme_boot_partition *part) +{ + struct nvme_get_log_args args = { + .lpo = 0, + .result = NULL, + .log = part, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .lid = NVME_LOG_LID_BOOT_PARTITION, + .len = len, + .nsid = NVME_NSID_NONE, + .csi = NVME_CSI_NVM, + .lsi = NVME_LOG_LSI_NONE, + .lsp = NVME_LOG_LSP_NONE, + .uuidx = NVME_UUID_NONE, + .rae = rae, + .ot = false, + }; + return nvme_get_log(&args); +} + +/** + * nvme_get_log_discovery() - + * @fd: File descriptor of nvme device + * @rae: Retain asynchronous events + * @offset: Offset of this log to retrieve + * @len: The allocated size for this portion of the log + * @log: User address to store the discovery log + * + * Supported only by fabrics discovery controllers, returning discovery + * records. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_get_log_discovery(int fd, bool rae, + __u32 offset, __u32 len, void *log) +{ + struct nvme_get_log_args args = { + .lpo = offset, + .result = NULL, + .log = log, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .lid = NVME_LOG_LID_DISCOVER, + .len = len, + .nsid = NVME_NSID_NONE, + .csi = NVME_CSI_NVM, + .lsi = NVME_LOG_LSI_NONE, + .lsp = NVME_LOG_LSP_NONE, + .uuidx = NVME_UUID_NONE, + .rae = rae, + .ot = false, + }; + return nvme_get_log(&args); +} + +/** + * nvme_get_log_media_unit_stat() - + * @fd: File descriptor of nvme device + * @domid: Domain Identifier selection, if supported + * @mus: User address to store the Media Unit statistics log + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise + */ +static inline int nvme_get_log_media_unit_stat(int fd, __u16 domid, + struct nvme_media_unit_stat_log *mus) +{ + struct nvme_get_log_args args = { + .lpo = 0, + .result = NULL, + .log = mus, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .lid = NVME_LOG_LID_MEDIA_UNIT_STATUS, + .len = sizeof(*mus), + .nsid = NVME_NSID_NONE, + .csi = NVME_CSI_NVM, + .lsi = domid, + .lsp = NVME_LOG_LSP_NONE, + .uuidx = NVME_UUID_NONE, + .rae = false, + .ot = false, + }; + return nvme_get_log(&args); +} + +/** + * nvme_get_log_support_cap_config_list() - + * @fd: File descriptor of nvme device + * @domid: Domain Identifier selection, if supported + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise + */ +static inline int nvme_get_log_support_cap_config_list(int fd, __u16 domid, + struct nvme_supported_cap_config_list_log *cap) +{ + struct nvme_get_log_args args = { + .lpo = 0, + .result = NULL, + .log = cap, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .lid = NVME_LOG_LID_SUPPORTED_CAP_CONFIG_LIST, + .len = sizeof(*cap), + .nsid = NVME_NSID_NONE, + .csi = NVME_CSI_NVM, + .lsi = domid, + .lsp = NVME_LOG_LSP_NONE, + .uuidx = NVME_UUID_NONE, + .rae = false, + .ot = false, + }; + return nvme_get_log(&args); +} + +/** + * nvme_get_log_reservation() - + * @fd: File descriptor of nvme device + * @rae: Retain asynchronous events + * @log: User address to store the reservation log + */ +static inline int nvme_get_log_reservation(int fd, bool rae, + struct nvme_resv_notification_log *log) +{ + return nvme_get_nsid_log(fd, rae, NVME_LOG_LID_RESERVATION, + NVME_NSID_ALL, sizeof(*log), log); +} + +/** + * nvme_get_log_sanitize() - + * @fd: File descriptor of nvme device + * @rae: Retain asynchronous events + * @log: User address to store the sanitize log + * + * The Sanitize Status log page reports sanitize operation time estimates and + * information about the most recent sanitize operation. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_get_log_sanitize(int fd, bool rae, + struct nvme_sanitize_log_page *log) +{ + return nvme_get_nsid_log(fd, rae, NVME_LOG_LID_SANITIZE, + NVME_NSID_ALL, sizeof(*log), log); +} + +/** + * nvme_get_log_zns_changed_zones() - + * @fd: File descriptor of nvme device + * @nsid: Namespace ID + * @rae: Retain asynchronous events + * @log: User address to store the changed zone log + * + * The list of zones that have changed state due to an exceptional event. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_get_log_zns_changed_zones(int fd, __u32 nsid, bool rae, + struct nvme_zns_changed_zone_log *log) +{ + struct nvme_get_log_args args = { + .lpo = 0, + .result = NULL, + .log = log, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .lid = NVME_LOG_LID_ZNS_CHANGED_ZONES, + .len = sizeof(*log), + .nsid = nsid, + .csi = NVME_CSI_ZNS, + .lsi = NVME_LOG_LSI_NONE, + .lsp = NVME_LOG_LSP_NONE, + .uuidx = NVME_UUID_NONE, + .rae = rae, + .ot = false, + }; + return nvme_get_log(&args); +} + +/** + * nvme_get_log_persistent_event() - + * @fd: File descriptor of nvme device + * @action: Action the controller should take during processing this command + * @size: Size of @pevent_log + * @pevent_log: User address to store the persistent event log + */ +static inline int nvme_get_log_persistent_event(int fd, + enum nvme_pevent_log_action action, + __u32 size, void *pevent_log) +{ + struct nvme_get_log_args args = { + .lpo = 0, + .result = NULL, + .log = pevent_log, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .lid = NVME_LOG_LID_PERSISTENT_EVENT, + .len = size, + .nsid = NVME_NSID_ALL, + .csi = NVME_CSI_NVM, + .lsi = NVME_LOG_LSI_NONE, + .lsp = action, + .uuidx = NVME_UUID_NONE, + .rae = false, + .ot = false, + }; + return nvme_get_log(&args); +} + +/** + * struct nvme_set_features_args - Arguments for the NVMe Admin Set Feature command + * @result: The command completion result from CQE dword0 + * @data: User address of feature data, if applicable + * @args_size: Size of &struct nvme_set_features_args + * @fd: File descriptor of nvme device + * @timeout: Timeout in ms + * @nsid: Namespace ID, if applicable + * @cdw11: Value to set the feature to + * @cdw12: Feature specific command dword12 field + * @cdw15: Feature specific command dword15 field + * @data_len: Length of feature data, if applicable, in bytes + * @save: Save value across power states + * @uuidx: UUID Index for differentiating vendor specific encoding + * @fid: Feature identifier + */ +struct nvme_set_features_args { + __u32 *result; + void *data; + int args_size; + int fd; + __u32 timeout; + __u32 nsid; + __u32 cdw11; + __u32 cdw12; + __u32 cdw13; + __u32 cdw15; + __u32 data_len; + bool save; + __u8 uuidx; + __u8 fid; +}; + +/** + * nvme_set_features() - Set a feature attribute + * @args: &struct nvme_set_features_args argument structure + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features(struct nvme_set_features_args *args); + +/** + * nvme_set_features_data() - Helper function for @nvme_set_features() + * @fd: File descriptor of nvme device + * @fid: Feature identifier + * @nsid: Namespace ID, if applicable + * @cdw11: Value to set the feature to + * @save: Save value across power states + * @data_len: Length of feature data, if applicable, in bytes + * @data: User address of feature data, if applicable + * @result: The command completion result from CQE dword0 + */ +static inline int nvme_set_features_data(int fd, __u8 fid, __u32 nsid, + __u32 cdw11, bool save, __u32 data_len, void *data, + __u32 *result) +{ + struct nvme_set_features_args args = { + .result = result, + .data = data, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .nsid = nsid, + .cdw11 = cdw11, + .cdw12 = 0, + .cdw13 = 0, + .cdw15 = 0, + .data_len = data_len, + .save = save, + .uuidx = 0, + .fid = fid, + }; + return nvme_set_features(&args); +} + +/** + * nvme_set_features_simple() - Helper functionn for @nvme_set_features() + * @fd: File descriptor of nvme device + * @fid: Feature identifier + * @nsid: Namespace ID, if applicable + * @cdw11: Value to set the feature to + * @save: Save value across power states + * @result: The command completion result from CQE dword0 + */ +static inline int nvme_set_features_simple(int fd, __u8 fid, __u32 nsid, + __u32 cdw11, bool save, __u32 *result) +{ + return nvme_set_features_data(fd, fid, nsid, cdw11, save, 0, NULL, + result); +} + +/** + * nvme_set_features_arbitration() - + * @fd: File descriptor of nvme device + * @ab: Arbitration Burst + * @lpw: Low Priority Weight + * @mpw: Medium Priority Weight + * @hpw: High Priority Weight + * @save: Save value across power states + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_arbitration(int fd, __u8 ab, __u8 lpw, __u8 mpw, + __u8 hpw, bool save, __u32 *result); + +/** + * nvme_set_features_power_mgmt() - + * @fd: File descriptor of nvme device + * @ps: Power State + * @wh: Workload Hint + * @save: Save value across power states + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_power_mgmt(int fd, __u8 ps, __u8 wh, bool save, + __u32 *result); + +/** + * nvme_set_features_lba_range() - + * @fd: File descriptor of nvme device + * @nsid: Namespace ID + * @nr_ranges: Number of ranges in @data + * @save: Save value across power states + * @data: User address of feature data + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_lba_range(int fd, __u32 nsid, __u32 nr_ranges, bool save, + struct nvme_lba_range_type *data, __u32 *result); + +/** + * nvme_set_features_temp_thresh() - + * @fd: File descriptor of nvme device + * @tmpth: Temperature Threshold + * @tmpsel: Threshold Temperature Select + * @thsel: Threshold Type Select + * @save: Save value across power states + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_temp_thresh(int fd, __u16 tmpth, __u8 tmpsel, + enum nvme_feat_tmpthresh_thsel thsel, + bool save, __u32 *result); + +/** + * nvme_set_features_err_recovery() - + * @fd: File descriptor of nvme device + * @nsid: Namespace ID + * @tler: Time-limited error recovery value + * @dulbe: Deallocated or Unwritten Logical Block Error Enable + * @save: Save value across power states + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_err_recovery(int fd, __u32 nsid, __u16 tler, + bool dulbe, bool save, __u32 *result); + +/** + * nvme_set_features_volatile_wc() - + * @fd: File descriptor of nvme device + * @wce: Write cache enable + * @save: Save value across power states + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_volatile_wc(int fd, bool wce, bool save, + __u32 *result); + +/** + * nvme_set_features_irq_coalesce() - + * @fd: File descriptor of nvme device + * @thr: Aggregation Threshold + * @time: Aggregation Time + * @save: Save value across power states + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_irq_coalesce(int fd, __u8 thr, __u8 time, + bool save, __u32 *result); + +/** + * nvme_set_features_irq_config() - + * @fd: File descriptor of nvme device + * @iv: Interrupt Vector + * @cd: Coalescing Disable + * @save: Save value across power states + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_irq_config(int fd, __u16 iv, bool cd, bool save, + __u32 *result); + +/** + * nvme_set_features_write_atomic() - + * @fd: File descriptor of nvme device + * @dn: Disable Normal + * @save: Save value across power states + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_write_atomic(int fd, bool dn, bool save, + __u32 *result); + +/** + * nvme_set_features_async_event() - + * @fd: File descriptor of nvme device + * @events: Events to enable + * @save: Save value across power states + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_async_event(int fd, __u32 events, bool save, + __u32 *result); + +/** + * nvme_set_features_auto_pst() - + * @fd: File descriptor of nvme device + * @apste: Autonomous Power State Transition Enable + * @apst: Autonomous Power State Transition + * @save: Save value across power states + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_auto_pst(int fd, bool apste, bool save, + struct nvme_feat_auto_pst *apst, + __u32 *result); + +/** + * nvme_set_features_timestamp() - + * @fd: File descriptor of nvme device + * @save: Save value across power states + * @timestamp: The current timestamp value to assign to this this feature + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_timestamp(int fd, bool save, __u64 timestamp); + +/** + * nvme_set_features_hctm() - + * @fd: File descriptor of nvme device + * @tmt2: Thermal Management Temperature 2 + * @tmt1: Thermal Management Temperature 1 + * @save: Save value across power states + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_hctm(int fd, __u16 tmt2, __u16 tmt1, bool save, + __u32 *result); + +/** + * nvme_set_features_nopsc() - + * @fd: File descriptor of nvme device + * @noppme: Non-Operational Power State Permissive Mode Enable + * @save: Save value across power states + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_nopsc(int fd, bool noppme, bool save, __u32 *result); + +/** + * nvme_set_features_rrl() - + * @fd: File descriptor of nvme device + * @rrl: Read recovery level setting + * @nvmsetid: NVM set id + * @save: Save value across power states + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_rrl(int fd, __u8 rrl, __u16 nvmsetid, bool save, + __u32 *result); + +/** + * nvme_set_features_plm_config() - + * @fd: File descriptor of nvme device + * @enable: Predictable Latency Enable + * @nvmsetid: NVM Set Identifier + * @save: Save value across power states + * @data: Pointer to structure nvme_plm_config + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_plm_config(int fd, bool enable, __u16 nvmsetid, + bool save, struct nvme_plm_config *data, + __u32*result); + +/** + * nvme_set_features_plm_window() - + * @fd: File descriptor of nvme device + * @sel: Window Select + * @nvmsetid: NVM Set Identifier + * @save: Save value across power states + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_plm_window(int fd, enum nvme_feat_plm_window_select sel, + __u16 nvmsetid, bool save, __u32 *result); + +/** + * nvme_set_features_lba_sts_interval() - + * @fd: File descriptor of nvme device + * @save: Save value across power states + * @lsiri: LBA Status Information Report Interval + * @lsipi: LBA Status Information Poll Interval + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_lba_sts_interval(int fd, __u16 lsiri, __u16 lsipi, + bool save, __u32 *result); + +/** + * nvme_set_features_host_behavior() - + * @fd: File descriptor of nvme device + * @save: Save value across power states + * @data: Pointer to structure nvme_feat_host_behavior + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_host_behavior(int fd, bool save, + struct nvme_feat_host_behavior *data); + +/** + * nvme_set_features_sanitize() - + * @fd: File descriptor of nvme device + * @nodrm: No-Deallocate Response Mode + * @save: Save value across power states + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_sanitize(int fd, bool nodrm, bool save, __u32 *result); + +/** + * nvme_set_features_endurance_evt_cfg() - + * @fd: File descriptor of nvme device + * @endgid: Endurance Group Identifier + * @egwarn: Flags to enable warning, see &enum nvme_eg_critical_warning_flags + * @save: Save value across power states + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_endurance_evt_cfg(int fd, __u16 endgid, __u8 egwarn, + bool save, __u32 *result); + +/** + * nvme_set_features_sw_progress() - + * @fd: File descriptor of nvme device + * @pbslc: Pre-boot Software Load Count + * @save: Save value across power states + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_sw_progress(int fd, __u8 pbslc, bool save, + __u32 *result); + +/** + * nvme_set_features_host_id() - + * @fd: File descriptor of nvme device + * @exhid: Enable Extended Host Identifier + * @save: Save value across power states + * @hostid: Host ID to set + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_host_id(int fd, bool exhid, bool save, __u8 *hostid); + +/** + * nvme_set_features_resv_mask() - + * @fd: File descriptor of nvme device + * @mask: Reservation Notification Mask Field + * @save: Save value across power states + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_resv_mask(int fd, __u32 mask, bool save, __u32 *result); + +/** + * nvme_set_features_resv_persist() - + * @fd: File descriptor of nvme device + * @ptpl: Persist Through Power Loss + * @save: Save value across power states + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_resv_persist(int fd, bool ptpl, bool save, __u32 *result); + +/** + * nvme_set_features_write_protect() - + * @fd: File descriptor of nvme device + * @state: Write Protection State + * @save: Save value across power states + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_features_write_protect(int fd, enum nvme_feat_nswpcfg_state state, + bool save, __u32 *result); +/** + * struct nvme_get_features_args - Arguments for the NVMe Admin Get Feature command + * @args_size: Size of &struct nvme_get_features_args + * @fd: File descriptor of nvme device + * @result: The command completion result from CQE dword0 + * @timeout: Timeout in ms + * @nsid: Namespace ID, if applicable + * @sel: Select which type of attribute to return, + * see &enum nvme_get_features_sel + * @cdw11: Feature specific command dword11 field + * @data_len: Length of feature data, if applicable, in bytes + * @data: User address of feature data, if applicable + * @fid: Feature identifier, see &enum nvme_features_id + * @uuidx: UUID Index for differentiating vendor specific encoding + */ +struct nvme_get_features_args { + __u32 *result; + void *data; + int args_size; + int fd; + __u32 timeout; + __u32 nsid; + enum nvme_get_features_sel sel; + __u32 cdw11; + __u32 data_len; + __u8 fid; + __u8 uuidx; +}; + +/** + * nvme_get_features() - Retrieve a feature attribute + * @args: &struct nvme_get_features_args argument structure + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features(struct nvme_get_features_args *args); + +/** + * nvme_get_features_data() - Helper function for @nvme_get_features() + * @fd: File descriptor of nvme device + * @fid: Feature identifier + * @nsid: Namespace ID, if applicable + * @data_len: Length of feature data, if applicable, in bytes + * @data: User address of feature data, if applicable + * @result: The command completion result from CQE dword0 + */ +static inline int nvme_get_features_data(int fd, enum nvme_features_id fid, + __u32 nsid, __u32 data_len, void *data, __u32 *result) +{ + struct nvme_get_features_args args = { + .result = result, + .data = data, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .nsid = nsid, + .sel = NVME_GET_FEATURES_SEL_CURRENT, + .cdw11 = 0, + .data_len = data_len, + .fid = fid, + .uuidx = NVME_UUID_NONE, + }; + + return nvme_get_features(&args); +} + +/** + * nvme_get_features_simple() - Helper function for @nvme_get_features() + * @fd: File descriptor of nvme device + * @fid: Feature identifier + * @nsid: Namespace ID, if applicable + * @result: The command completion result from CQE dword0 + */ +static inline int nvme_get_features_simple(int fd, enum nvme_features_id fid, + __u32 nsid, __u32 *result) +{ + return nvme_get_features_data(fd, fid, nsid, 0, NULL, result); +} + +/** + * nvme_get_features_arbitration() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_arbitration(int fd, enum nvme_get_features_sel sel, + __u32 *result); + +/** + * nvme_get_features_power_mgmt() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_power_mgmt(int fd, enum nvme_get_features_sel sel, + __u32 *result); + +/** + * nvme_get_features_lba_range() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @data: User address of feature data, if applicable + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_lba_range(int fd, enum nvme_get_features_sel sel, + struct nvme_lba_range_type *data, + __u32 *result); + +/** + * nvme_get_features_temp_thresh() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_temp_thresh(int fd, enum nvme_get_features_sel sel, + __u32 *result); + +/** + * nvme_get_features_err_recovery() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_err_recovery(int fd, enum nvme_get_features_sel sel, + __u32 *result); + +/** + * nvme_get_features_volatile_wc() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_volatile_wc(int fd, enum nvme_get_features_sel sel, + __u32 *result); + +/** + * nvme_get_features_num_queues() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_num_queues(int fd, enum nvme_get_features_sel sel, + __u32 *result); + +/** + * nvme_get_features_irq_coalesce() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_irq_coalesce(int fd, enum nvme_get_features_sel sel, + __u32 *result); + +/** + * nvme_get_features_irq_config() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @iv: + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_irq_config(int fd, enum nvme_get_features_sel sel, + __u16 iv, __u32 *result); + +/** + * nvme_get_features_write_atomic() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_write_atomic(int fd, enum nvme_get_features_sel sel, + __u32 *result); + +/** + * nvme_get_features_async_event() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_async_event(int fd, enum nvme_get_features_sel sel, + __u32 *result); + +/** + * nvme_get_features_auto_pst() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @apst: + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_auto_pst(int fd, enum nvme_get_features_sel sel, + struct nvme_feat_auto_pst *apst, __u32 *result); + +/** + * nvme_get_features_host_mem_buf() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_host_mem_buf(int fd, enum nvme_get_features_sel sel, + __u32 *result); + +/** + * nvme_get_features_timestamp() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @ts: Current timestamp + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_timestamp(int fd, enum nvme_get_features_sel sel, + struct nvme_timestamp *ts); + +/** + * nvme_get_features_kato() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_kato(int fd, enum nvme_get_features_sel sel, __u32 *result); + +/** + * nvme_get_features_hctm() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_hctm(int fd, enum nvme_get_features_sel sel, __u32 *result); + +/** + * nvme_get_features_nopsc() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_nopsc(int fd, enum nvme_get_features_sel sel, __u32 *result); + +/** + * nvme_get_features_rrl() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_rrl(int fd, enum nvme_get_features_sel sel, __u32 *result); + +/** + * nvme_get_features_plm_config() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @nvmsetid: NVM set id + * @data: + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_plm_config(int fd, enum nvme_get_features_sel sel, + __u16 nvmsetid, struct nvme_plm_config *data, + __u32 *result); + +/** + * nvme_get_features_plm_window() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @nvmsetid: NVM set id + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_plm_window(int fd, enum nvme_get_features_sel sel, + __u16 nvmsetid, __u32 *result); + +/** + * nvme_get_features_lba_sts_interval() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_lba_sts_interval(int fd, enum nvme_get_features_sel sel, + __u32 *result); + +/** + * nvme_get_features_host_behavior() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @data: Poniter to structure nvme_feat_host_behavior + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_host_behavior(int fd, enum nvme_get_features_sel sel, + struct nvme_feat_host_behavior *data, + __u32 *result); + +/** + * nvme_get_features_sanitize() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_sanitize(int fd, enum nvme_get_features_sel sel, + __u32 *result); + +/** + * nvme_get_features_endurance_event_cfg() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @endgid: Endurance Group Identifier + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_endurance_event_cfg(int fd, enum nvme_get_features_sel sel, + __u16 endgid, __u32 *result); + +/** + * nvme_get_features_sw_progress() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_sw_progress(int fd, enum nvme_get_features_sel sel, + __u32 *result); + +/** + * nvme_get_features_host_id() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @exhid: Enable Extended Host Identifier + * @len: Length of @hostid + * @hostid: Buffer for returned host ID + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_host_id(int fd, enum nvme_get_features_sel sel, + bool exhid, __u32 len, __u8 *hostid); + +/** + * nvme_get_features_resv_mask() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_resv_mask(int fd, enum nvme_get_features_sel sel, + __u32 *result); + +/** + * nvme_get_features_resv_persist() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_resv_persist(int fd, enum nvme_get_features_sel sel, + __u32 *result); + +/** + * nvme_get_features_write_protect() - + * @fd: File descriptor of nvme device + * @nsid: Namespace ID + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_write_protect(int fd, __u32 nsid, + enum nvme_get_features_sel sel, + __u32 *result); + +/** + * nvme_get_features_iocs_profile() - + * @fd: File descriptor of nvme device + * @sel: Select which type of attribute to return, see &enum nvme_get_features_sel + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_features_iocs_profile(int fd, enum nvme_get_features_sel sel, + __u32 *result); + +/** + * struct nvme_format_nvm_args - Arguments for the Format Nvme Namespace command + * @result: The command completion result from CQE dword0 + * @args_size: Size of &struct nvme_format_nvm_args + * @fd: File descriptor of nvme device + * @timeout: Set to override default timeout to this value in milliseconds; + * useful for long running formats. 0 will use system default. + * @nsid: Namespace ID to format + * @mset: Metadata settings (extended or separated), true if extended + * @pi: Protection information type + * @pil: Protection information location (beginning or end), true if end + * @ses: Secure erase settings + * @lbaf: Logical block address format + */ +struct nvme_format_nvm_args { + __u32 *result; + int args_size; + int fd; + __u32 timeout; + __u32 nsid; + enum nvme_cmd_format_mset mset; + enum nvme_cmd_format_pi pi; + enum nvme_cmd_format_pil pil; + enum nvme_cmd_format_ses ses; + __u8 lbaf; +}; + +/** + * nvme_format_nvm() - Format nvme namespace(s) + * @args: &struct nvme_format_nvme_args argument structure + * + * The Format NVM command low level formats the NVM media. This command is used + * by the host to change the LBA data size and/or metadata size. A low level + * format may destroy all data and metadata associated with all namespaces or + * only the specific namespace associated with the command + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_format_nvm(struct nvme_format_nvm_args *args); + +/** + * struct nvme_ns_mgmt_args - Arguments for NVMe Namespace Management command + * @result: NVMe command result + * @ns: Namespace identication descriptors + * @args_size: Size of &struct nvme_ns_mgmt_args + * @fd: File descriptor of nvme device + * @timeout: Timeout in ms + * @nsid: Namespace identifier + * @sel: Type of management operation to perform + * @csi: Command Set Identifier + */ +struct nvme_ns_mgmt_args { + __u32 *result; + struct nvme_id_ns *ns; + int args_size; + int fd; + __u32 timeout; + __u32 nsid; + enum nvme_ns_mgmt_sel sel; + __u8 csi; +}; + +/** + * nvme_ns_mgmt() - Issue a Namespace management command + * @args: &struct nvme_ns_mgmt_args Argument structure + */ +int nvme_ns_mgmt(struct nvme_ns_mgmt_args *args); + +/** + * nvme_ns_mgmt_create() - + * @fd: File descriptor of nvme device + * @ns: Namespace identification that defines ns creation parameters + * @nsid: On success, set to the namespace id that was created + * @timeout: Overide the default timeout to this value in milliseconds; + * set to 0 to use the system default. + * @csi: Command Set Identifier + * + * On successful creation, the namespace exists in the subsystem, but is not + * attached to any controller. Use the nvme_ns_attach_ctrls() to assign the + * namespace to one or more controllers. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_ns_mgmt_create(int fd, struct nvme_id_ns *ns, + __u32 *nsid, __u32 timeout, __u8 csi) +{ + struct nvme_ns_mgmt_args args = { + .result = nsid, + .ns = ns, + .args_size = sizeof(args), + .fd = fd, + .timeout = timeout, + .nsid = NVME_NSID_NONE, + .sel = NVME_NS_MGMT_SEL_CREATE, + .csi = csi, + }; + + return nvme_ns_mgmt(&args); +} + +/** + * nvme_ns_mgmt_delete() - + * @fd: File descriptor of nvme device + * @nsid: Namespace identifier to delete + * + * It is recommended that a namespace being deleted is not attached to any + * controller. Use the nvme_ns_detach_ctrls() first if the namespace is still + * attached. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_ns_mgmt_delete(int fd, __u32 nsid) +{ + struct nvme_ns_mgmt_args args = { + .result = NULL, + .ns = NULL, + .args_size = sizeof(args), + .fd = fd, + .timeout = 0, + .nsid = nsid, + .sel = NVME_NS_MGMT_SEL_DELETE, + .csi = 0, + }; + + return nvme_ns_mgmt(&args); +} + +/** + * struct nvme_ns_attach_args - Arguments for Nvme Namespace Management command + * @result: NVMe command result + * @ctrlist: Controller list to modify attachment state of nsid + * @args_size: Size of &struct nvme_ns_attach_args + * @fd: File descriptor of nvme device + * @timeout: Timeout in ms + * @nsid: Namespace ID to execute attach selection + * @sel: Attachment selection, see &enum nvme_ns_attach_sel + */ +struct nvme_ns_attach_args { + __u32 *result; + struct nvme_ctrl_list *ctrlist; + int args_size; + int fd; + __u32 timeout; + __u32 nsid; + enum nvme_ns_attach_sel sel; +}; + +/** + * nvme_ns_attach() - Attach or detach namespace to controller(s) + * @args: &struct nvme_ns_attach_args Argument structure + */ +int nvme_ns_attach(struct nvme_ns_attach_args *args); + +/** + * nvme_ns_attach_ctrls() - + * @fd: File descriptor of nvme device + * @nsid: Namespace ID to attach + * @ctrlist: Controller list to modify attachment state of nsid + */ +static inline int nvme_ns_attach_ctrls(int fd, __u32 nsid, + struct nvme_ctrl_list *ctrlist) +{ + struct nvme_ns_attach_args args = { + .result = NULL, + .ctrlist = ctrlist, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .nsid = nsid, + .sel = NVME_NS_ATTACH_SEL_CTRL_ATTACH, + }; + + return nvme_ns_attach(&args); +} + +/** + * nvme_ns_detach_ctrls() - + * @fd: File descriptor of nvme device + * @nsid: Namespace ID to detach + * @ctrlist: Controller list to modify attachment state of nsid + */ +static inline int nvme_ns_detach_ctrls(int fd, __u32 nsid, + struct nvme_ctrl_list *ctrlist) +{ + struct nvme_ns_attach_args args = { + .result = NULL, + .ctrlist = ctrlist, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .nsid = nsid, + .sel = NVME_NS_ATTACH_SEL_CTRL_DEATTACH, + }; + + return nvme_ns_attach(&args); +} + +/** + * struct nvme_fw_download_args - Arguments for the NVMe Firmware Download command + * @args_size: Size of &struct nvme_fw_download_args + * @fd: File descriptor of nvme device + * @result: The command completion result from CQE dword0 + * @timeout: Timeout in ms + * @offset: Offset in the firmware data + * @data: Userspace address of the firmware data + * @data_len: Length of data in this command in bytes + */ +struct nvme_fw_download_args { + __u32 *result; + void *data; + int args_size; + int fd; + __u32 timeout; + __u32 offset; + __u32 data_len; +}; + +/** + * nvme_fw_download() - Download part or all of a firmware image to the + * controller + * @args: &struct nvme_fw_download_args argument structure + * + * The Firmware Image Download command downloads all or a portion of an image + * for a future update to the controller. The Firmware Image Download command + * downloads a new image (in whole or in part) to the controller. + * + * The image may be constructed of multiple pieces that are individually + * downloaded with separate Firmware Image Download commands. Each Firmware + * Image Download command includes a Dword Offset and Number of Dwords that + * specify a dword range. + * + * The new firmware image is not activated as part of the Firmware Image + * Download command. Use the nvme_fw_commit() to activate a newly downloaded + * image. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_fw_download(struct nvme_fw_download_args *args); + +/** + * struct nvme_fw_commit_args - Arguments for the NVMe Firmware Commit command + * @args_size: Size of &struct nvme_fw_commit_args + * @fd: File descriptor of nvme device + * @action: Action to use for the firmware image, see &enum nvme_fw_commit_ca + * @timeout: Timeout in ms + * @result: The command completion result from CQE dword0 + * @slot: Firmware slot to commit the downloaded image + * @bpid: Set to true to select the boot partition id + */ +struct nvme_fw_commit_args { + __u32 *result; + int args_size; + int fd; + __u32 timeout; + enum nvme_fw_commit_ca action; + __u8 slot; + bool bpid; +}; + +/** + * nvme_fw_commit() - Commit firmware using the specified action + * @args: &struct nvme_fw_commit_args argument structure + * + * The Firmware Commit command modifies the firmware image or Boot Partitions. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. The command + * status response may specify additional reset actions required to complete + * the commit process. + */ +int nvme_fw_commit(struct nvme_fw_commit_args *args); + +/** + * struct nvme_security_send_args - Arguments for the NVMe Security Send command + * @result: The command completion result from CQE dword0 + * @data: Security data payload to send + * @args_size: Size of &struct nvme_security_send_args + * @fd: File descriptor of nvme device + * @timeout: Timeout in ms + * @nsid: Namespace ID to issue security command on + * @tl: Protocol specific transfer length + * @data_len: Data length of the payload in bytes + * @nssf: NVMe Security Specific field + * @spsp0: Security Protocol Specific field + * @spsp1: Security Protocol Specific field + * @secp: Security Protocol + */ +struct nvme_security_send_args { + __u32 *result; + void *data; + int args_size; + int fd; + __u32 timeout; + __u32 nsid; + __u32 tl; + __u32 data_len; + __u8 nssf; + __u8 spsp0; + __u8 spsp1; + __u8 secp; +}; + +/** + * nvme_security_send() - + * @args: &struct nvme_security_send argument structure + * + * The Security Send command transfers security protocol data to the + * controller. The data structure transferred to the controller as part of this + * command contains security protocol specific commands to be performed by the + * controller. The data structure transferred may also contain data or + * parameters associated with the security protocol commands. + * + * The security data is protocol specific and is not defined by the NVMe + * specification. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_security_send(struct nvme_security_send_args *args); + +/** + * struct nvme_security_receive_args - Arguments for the NVMe Security Receive command + * @result: The command completion result from CQE dword0 + * @data: Security data payload to send + * @args_size: Size of &struct nvme_security_receive_args + * @fd: File descriptor of nvme device + * @timeout: Timeout in ms + * @nsid: Namespace ID to issue security command on + * @al: Protocol specific allocation length + * @data_len: Data length of the payload in bytes + * @nssf: NVMe Security Specific field + * @spsp0: Security Protocol Specific field + * @spsp1: Security Protocol Specific field + * @secp: Security Protocol + */ +struct nvme_security_receive_args { + __u32 *result; + void *data; + int args_size; + int fd; + __u32 timeout; + __u32 nsid; + __u32 al; + __u32 data_len; + __u8 nssf; + __u8 spsp0; + __u8 spsp1; + __u8 secp; +}; + +/** + * nvme_security_receive() - + * @args: &struct nvme_security_recevice argument structure + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_security_receive(struct nvme_security_receive_args *args); + +/** + * struct nvme_get_lba_status_args - Arguments for the NVMe Get LBA Status command + * @lbas: Data payload to return status descriptors + * @result: The command completion result from CQE dword0 + * @slba: Starting logical block address to check statuses + * @args_size: Size of &struct nvme_get_lba_status_args + * @fd: File descriptor of nvme device + * @timeout: Timeout in ms + * @nsid: Namespace ID to retrieve LBA status + * @mndw: Maximum number of dwords to return + * @atype: Action type mechanism to determine LBA status desctriptors to + * return, see &enum nvme_lba_status_atype + * @rl: Range length from slba to perform the action + */ +struct nvme_get_lba_status_args { + __u64 slba; + __u32 *result; + struct nvme_lba_status *lbas; + int args_size; + int fd; + __u32 timeout; + __u32 nsid; + __u32 mndw; + enum nvme_lba_status_atype atype; + __u16 rl; +}; + +/** + * nvme_get_lba_status() - Retrieve information on possibly unrecoverable LBAs + * @args: &struct nvme_get_lba_status_args argument structure + * + * The Get LBA Status command requests information about Potentially + * Unrecoverable LBAs. Refer to the specification for action type descriptions. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_lba_status(struct nvme_get_lba_status_args *args); + +/** + * struct nvme_directive_send_args - Arguments for the NVMe Directive Send command + * @result: If successful, the CQE dword0 value + * @data: Data payload to to be send + * @args_size: Size of &struct nvme_directive_send_args + * @fd: File descriptor of nvme device + * @timeout: Timeout in ms + * @nsid: Namespace ID, if applicable + * @doper: Directive send operation, see &enum nvme_directive_send_doper + * @dtype: Directive type, see &enum nvme_directive_dtype + * @cdw12: Directive specific command dword12 + * @data_len: Length of data payload in bytes + * @dspec: Directive specific field + */ +struct nvme_directive_send_args { + __u32 *result; + void *data; + int args_size; + int fd; + __u32 timeout; + __u32 nsid; + enum nvme_directive_send_doper doper; + enum nvme_directive_dtype dtype; + __u32 cdw12; + __u32 data_len; + __u16 dspec; +}; + +/** + * nvme_directive_send() - Send directive command + * @args: &struct nvme_directive_send_args argument structure + * + * Directives is a mechanism to enable host and NVM subsystem or controller + * information exchange. The Directive Send command transfers data related to a + * specific Directive Type from the host to the controller. + * + * See the NVMe specification for more information. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_directive_send(struct nvme_directive_send_args *args); + +/** + * nvme_directive_send_id_endir() - + * @fd: File descriptor of nvme device + * @nsid: Namespace Identifier + * @endir: Enable Directive + * @dtype: Directive Type + * @id: Pointer to structure nvme_id_directives + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_directive_send_id_endir(int fd, __u32 nsid, bool endir, + enum nvme_directive_dtype dtype, + struct nvme_id_directives *id); + +/** + * nvme_directive_send_stream_release_identifier() - + * @fd: File descriptor of nvme device + * @nsid: Namespace ID + * @stream_id: Stream identifier + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_directive_send_stream_release_identifier(int fd, + __u32 nsid, __u16 stream_id) +{ + struct nvme_directive_send_args args = { + .result = NULL, + .data = NULL, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .nsid = nsid, + .doper = NVME_DIRECTIVE_SEND_STREAMS_DOPER_RELEASE_IDENTIFIER, + .dtype = NVME_DIRECTIVE_DTYPE_STREAMS, + .cdw12 = 0, + .data_len = 0, + .dspec = stream_id, + }; + + return nvme_directive_send(&args); +} + +/** + * nvme_directive_send_stream_release_resource() - + * @fd: File descriptor of nvme device + * @nsid: Namespace ID + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_directive_send_stream_release_resource(int fd, __u32 nsid) +{ + struct nvme_directive_send_args args = { + .result = NULL, + .data = NULL, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .nsid = nsid, + .doper = NVME_DIRECTIVE_SEND_STREAMS_DOPER_RELEASE_RESOURCE, + .dtype = NVME_DIRECTIVE_DTYPE_STREAMS, + .cdw12 = 0, + .data_len = 0, + .dspec = 0, + }; + + return nvme_directive_send(&args); +} + +/** + * struct nvme_directive_recv_args - Arguments for the NVMe Directive Receive command + * @result: If successful, the CQE dword0 value + * @data: Usespace address of data payload + * @args_size: Size of &struct nvme_directive_recv_args + * @fd: File descriptor of nvme device + * @timeout: Timeout in ms + * @nsid: Namespace ID, if applicable + * @doper: Directive send operation, see &enum nvme_directive_send_doper + * @dtype: Directive type, see &enum nvme_directive_dtype + * @cdw12: Directive specific command dword12 + * @data_len: Length of data payload in bytes + * @dspec: Directive specific field + */ +struct nvme_directive_recv_args { + __u32 *result; + void *data; + int args_size; + int fd; + __u32 timeout; + __u32 nsid; + enum nvme_directive_receive_doper doper; + enum nvme_directive_dtype dtype; + __u32 cdw12; + __u32 data_len; + __u16 dspec; +}; + +/** + * nvme_directive_recv() - Receive directive specific data + * @args: &struct nvme_directive_recv_args argument structure + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_directive_recv(struct nvme_directive_recv_args *args); + +/** + * nvme_directive_recv_identify_parameters() - + * @fd: File descriptor of nvme device + * @nsid: Namespace ID + * @id: Identify parameters buffer + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_directive_recv_identify_parameters(int fd, __u32 nsid, + struct nvme_id_directives *id) +{ + struct nvme_directive_recv_args args = { + .result = NULL, + .data = id, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .nsid = nsid, + .doper = NVME_DIRECTIVE_RECEIVE_IDENTIFY_DOPER_PARAM, + .dtype = NVME_DIRECTIVE_DTYPE_IDENTIFY, + .cdw12 = 0, + .data_len = sizeof(*id), + .dspec = 0, + }; + + return nvme_directive_recv(&args); +} + +/** + * nvme_directive_recv_stream_parameters() - + * @fd: File descriptor of nvme device + * @nsid: Namespace ID + * @parms: Streams directive parameters buffer + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_directive_recv_stream_parameters(int fd, __u32 nsid, + struct nvme_streams_directive_params *parms) +{ + struct nvme_directive_recv_args args = { + .result = NULL, + .data = parms, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .nsid = nsid, + .doper = NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_PARAM, + .dtype = NVME_DIRECTIVE_DTYPE_STREAMS, + .cdw12 = 0, + .data_len = sizeof(*parms), + .dspec = 0, + }; + + return nvme_directive_recv(&args); +} + +/** + * nvme_directive_recv_stream_status() - + * @fd: File descriptor of nvme device + * @nsid: Namespace ID + * @nr_entries: Number of streams to receive + * @id: Stream status buffer + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_directive_recv_stream_status(int fd, __u32 nsid, + unsigned nr_entries, + struct nvme_streams_directive_status *id) +{ + struct nvme_directive_recv_args args = { + .result = NULL, + .data = id, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .nsid = nsid, + .doper = NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_STATUS, + .dtype = NVME_DIRECTIVE_DTYPE_STREAMS, + .cdw12 = 0, + .data_len = sizeof(*id), + .dspec = 0, + }; + + return nvme_directive_recv(&args); +} + +/** + * nvme_directive_recv_stream_allocate() - + * @fd: File descriptor of nvme device + * @nsid: Namespace ID + * @nsr: Namespace Streams Requested + * @result: If successful, the CQE dword0 value + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_directive_recv_stream_allocate(int fd, __u32 nsid, + __u16 nsr, __u32 *result) +{ + struct nvme_directive_recv_args args = { + .result = result, + .data = NULL, + .args_size = sizeof(args), + .fd = fd, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .nsid = nsid, + .doper = NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_RESOURCE, + .dtype = NVME_DIRECTIVE_DTYPE_STREAMS, + .cdw12 = nsr, + .data_len = 0, + .dspec = 0, + }; + + return nvme_directive_recv(&args); +} + +/** + * struct nvme_capacity_mgmt_args - Arguments for the NVMe Capacity Management command + * @result: If successful, the CQE dword0 value + * @args_size: Size of &struct nvme_capacity_mgmt_args + * @fd: File descriptor of nvme device + * @cdw11: Least significant 32 bits of the capacity in bytes of the + * Endurance Group or NVM Set to be created + * @cdw12: Most significant 32 bits of the capacity in bytes of the + * Endurance Group or NVM Set to be created + * @timeout: Timeout in ms + * @element_id: Value specific to the value of the Operation field + * @op: Operation to be performed by the controller + */ +struct nvme_capacity_mgmt_args { + __u32 *result; + int args_size; + int fd; + __u32 timeout; + __u32 cdw11; + __u32 cdw12; + __u16 element_id; + __u8 op; +}; + +/** + * nvme_capacity_mgmt() - + * @args: &struct nvme_capacity_mgmt_args argument structure + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_capacity_mgmt(struct nvme_capacity_mgmt_args *args); + +/** + * struct nvme_lockdown_args - Arguments for the NVME Lockdown command + * @args_size: Size of &struct nvme_lockdown_args + * @fd: File descriptor of nvme device + * @result: The command completion result from CQE dword0 + * @timeout: Timeout in ms (0 for default timeout) + * @scp: Scope of the command + * @prhbt: Prohibit or allow the command opcode or Set Features command + * @ifc: Affected interface + * @ofi: Opcode or Feature Identifier + * @uuidx: UUID Index if controller supports this id selection method + */ +struct nvme_lockdown_args { + __u32 *result; + int args_size; + int fd; + __u32 timeout; + __u8 scp; + __u8 prhbt; + __u8 ifc; + __u8 ofi; + __u8 uuidx; +}; + +/** + * nvme_lockdown() - Issue lockdown command + * @args: &struct nvme_lockdown_args argument structure + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_lockdown(struct nvme_lockdown_args *args); + +/** + * struct nvme_set_property_args - Arguments for NVMe Set Property command + * @args_size: Size of &struct nvme_set_property_args + * @fd: File descriptor of nvme device + * @result: The command completion result from CQE dword0 + * @timeout: Timeout in ms + * @offset: Property offset from the base to set + * @value: The value to set the property + */ +struct nvme_set_property_args { + __u64 value; + __u32 *result; + int args_size; + int fd; + __u32 timeout; + int offset; +}; + +/** + * nvme_set_property() - Set controller property + * @args: &struct nvme_set_property_args argument structure + * + * This is an NVMe-over-Fabrics specific command, not applicable to PCIe. These + * properties align to the PCI MMIO controller registers. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_set_property(struct nvme_set_property_args *args); + +/** + * struct nvme_get_property_args - Arguments for NVMe Get Property command + * @value: Where the property's value will be stored on success + * @args_size: Size of &struct nvme_get_property_args + * @fd: File descriptor of nvme device + * @offset: Property offset from the base to retrieve + * @timeout: Timeout in ms + */ +struct nvme_get_property_args { + __u64 *value; + int args_size; + int fd; + __u32 timeout; + int offset; +}; + +/** + * nvme_get_property() - Get a controller property + * @args: &struct nvme_get_propert_args argument structure + * + * This is an NVMe-over-Fabrics specific command, not applicable to PCIe. These + * properties align to the PCI MMIO controller registers. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_property(struct nvme_get_property_args *args); + +/** + * struct nvme_sanitize_nvm_args - Arguments for the NVMe Sanitize NVM command + * @result: The command completion result from CQE dword0 + * @args_size: Size of &struct nvme_sanitize_nvm_args + * @fd: File descriptor of nvme device + * @timeout: Timeout in ms + * @ovrpat: Overwrite pattern + * @sanact: Sanitize action, see &enum nvme_sanitize_sanact + * @ause: Set to allow unrestriced sanitize exit + * @owpass: Overwrite pass count + * @oipbp: Set to overwrite invert pattern between passes + * @nodas: Set to not deallocate blocks after sanitizing + */ +struct nvme_sanitize_nvm_args { + __u32 *result; + int args_size; + int fd; + __u32 timeout; + enum nvme_sanitize_sanact sanact; + __u32 ovrpat; + bool ause; + __u8 owpass; + bool oipbp; + bool nodas; +}; + +/** + * nvme_sanitize_nvm() - Start a sanitize operation + * @args: &struct nvme_sanitize_nvm_args argument structure + * + * A sanitize operation alters all user data in the NVM subsystem such that + * recovery of any previous user data from any cache, the non-volatile media, + * or any Controller Memory Buffer is not possible. + * + * The Sanitize command starts a sanitize operation or to recover from a + * previously failed sanitize operation. The sanitize operation types that may + * be supported are Block Erase, Crypto Erase, and Overwrite. All sanitize + * operations are processed in the background, i.e., completion of the sanitize + * command does not indicate completion of the sanitize operation. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_sanitize_nvm(struct nvme_sanitize_nvm_args *args); + +/** + * struct nvme_dev_self_test_args - Arguments for the NVMe Device Self Test command + * @result: The command completion result from CQE dword0 + * @args_size: Size of &struct nvme_dev_self_test_args + * @fd: File descriptor of nvme device + * @nsid: Namespace ID to test + * @stc: Self test code, see &enum nvme_dst_stc + * @timeout: Timeout in ms + */ +struct nvme_dev_self_test_args { + __u32 *result; + int args_size; + int fd; + __u32 timeout; + __u32 nsid; + enum nvme_dst_stc stc; +}; + +/** + * nvme_dev_self_test() - Start or abort a self test + * @args: &struct nvme_dev_self_test argument structure + * + * The Device Self-test command starts a device self-test operation or abort a + * device self-test operation. A device self-test operation is a diagnostic + * testing sequence that tests the integrity and functionality of the + * controller and may include testing of the media associated with namespaces. + * The controller may return a response to this command immediately while + * running the self-test in the background. + * + * Set the 'nsid' field to 0 to not include namepsaces in the test. Set to + * 0xffffffff to test all namespaces. All other values tests a specific + * namespace, if present. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_dev_self_test(struct nvme_dev_self_test_args *args); + +/** + * struct nvme_virtual_mgmt_args - Arguments for the NVMe Virtualization + * resource management command + * @args_size: Size of &struct nvme_virtual_mgmt_args + * @fd: File descriptor of nvme device + * @result: If successful, the CQE dword0 + * @timeout: Timeout in ms + * @act: Virtual resource action, see &enum nvme_virt_mgmt_act + * @rt: Resource type to modify, see &enum nvme_virt_mgmt_rt + * @cntlid: Controller id for which resources are bing modified + * @nr: Number of resources being allocated or assigned + */ +struct nvme_virtual_mgmt_args { + __u32 *result; + int args_size; + int fd; + __u32 timeout; + enum nvme_virt_mgmt_act act; + enum nvme_virt_mgmt_rt rt; + __u16 cntlid; + __u16 nr; +}; + +/** + * nvme_virtual_mgmt() - Virtualization resource management + * @args: &struct nvme_virtual_mgmt_args argument structure + * + * The Virtualization Management command is supported by primary controllers + * that support the Virtualization Enhancements capability. This command is + * used for several functions: + * + * - Modifying Flexible Resource allocation for the primary controller + * - Assigning Flexible Resources for secondary controllers + * - Setting the Online and Offline state for secondary controllers + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_virtual_mgmt(struct nvme_virtual_mgmt_args *args); + +/** + * nvme_flush() - Send an nvme flush command + * @fd: File descriptor of nvme device + * @nsid: Namespace identifier + * + * The Flush command requests that the contents of volatile write cache be made + * non-volatile. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_flush(int fd, __u32 nsid) { + struct nvme_passthru_cmd cmd = {}; + + cmd.opcode = nvme_cmd_flush; + cmd.nsid = nsid; + + return nvme_submit_io_passthru(fd, &cmd, NULL); +} + +/** + * struct nvme_io_args - Arguments for NVMe I/O commands + * @slba: Starting logical block + * @storage_tag: This filed specifies Variable Sized Expected Logical Block + * Storage Tag (ELBST) and Expected Logical Block Reference + * Tag (ELBRT) + * @result: The command completion result from CQE dword0 + * @data: Pointer to user address of the data buffer + * @metadata: Pointer to user address of the metadata buffer + * @args_size: Size of &struct nvme_io_args + * @fd: File descriptor of nvme device + * @timeout: Timeout in ms + * @nsid: Namespace ID + * @data_len: Length of user buffer, @data, in bytes + * @metadata_len:Length of user buffer, @metadata, in bytes + * @nlb: Number of logical blocks to send (0's based value) + * @control: Command control flags, see &enum nvme_io_control_flags. + * @apptag: This field specifies the Application Tag Mask expected value. + * Used only if the namespace is formatted to use end-to-end + * protection information. + * @appmask: This field specifies the Application Tag expected value. Used + * only if the namespace is formatted to use end-to-end protection + * information. + * @reftag: This field specifies the Initial Logical Block Reference Tag + * expected value. Used only if the namespace is formatted to use + * end-to-end protection information. + * @dspec: Directive specific value + * @dsm: Data set management attributes, see &enum nvme_io_dsm_flags + */ +struct nvme_io_args { + __u64 slba; + __u64 storage_tag; + __u32 *result; + void *data; + void *metadata; + int args_size; + int fd; + __u32 timeout; + __u32 nsid; + __u32 reftag; + __u32 data_len; + __u32 metadata_len; + __u16 nlb; + __u16 control; + __u16 apptag; + __u16 appmask; + __u16 dspec; + __u8 dsm; +}; + +/** + * nvme_io() - Submit an nvme user I/O command + * @args: &struct nvme_io_args argument structure + * @opcode: Opcode to execute + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_io(struct nvme_io_args *args, __u8 opcode); + +/** + * nvme_read() - Submit an nvme user read command + * @args: &struct nvme_io_args argument structure + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_read(struct nvme_io_args *args) +{ + return nvme_io(args, nvme_cmd_read); +} + +/** + * nvme_write() - Submit an nvme user write command + * @args: &struct nvme_io_args argument structure + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_write(struct nvme_io_args *args) +{ + return nvme_io(args, nvme_cmd_write); +} + +/** + * nvme_compare() - Submit an nvme user compare command + * @args: &struct nvme_io_args argument structure + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_compare(struct nvme_io_args *args) +{ + return nvme_io(args, nvme_cmd_compare); +} + +/** + * nvme_write_zeros() - Submit an nvme write zeroes command + * @args: &struct nvme_io_args argument structure + * + * The Write Zeroes command sets a range of logical blocks to zero. After + * successful completion of this command, the value returned by subsequent + * reads of logical blocks in this range shall be all bytes cleared to 0h until + * a write occurs to this LBA range. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_write_zeros(struct nvme_io_args *args) +{ + return nvme_io(args, nvme_cmd_write_zeroes); +} + +/** + * nvme_write_uncorrectable() - Submit an nvme write uncorrectable command + * @args: &struct nvme_io_args argument structure + * + * The Write Uncorrectable command marks a range of logical blocks as invalid. + * When the specified logical block(s) are read after this operation, a failure + * is returned with Unrecovered Read Error status. To clear the invalid logical + * block status, a write operation on those logical blocks is required. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_write_uncorrectable(struct nvme_io_args *args) +{ + return nvme_io(args, nvme_cmd_write_uncor); +} + +/** + * nvme_verify() - Send an nvme verify command + * @args: &struct nvme_io_args argument structure + * + * The Verify command verifies integrity of stored information by reading data + * and metadata, if applicable, for the LBAs indicated without transferring any + * data or metadata to the host. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_verify(struct nvme_io_args *args) +{ + return nvme_io(args, nvme_cmd_verify); +} + +/** + * struct nvme_dsm_args - Arguments for the NVMe Dataset Management command + * @result: The command completion result from CQE dword0 + * @dsm: The data set management attributes + * @args_size: Size of &struct nvme_dsm_args + * @fd: File descriptor of nvme device + * @timeout: Timeout in ms + * @nsid: Namespace identifier + * @attrs: DSM attributes, see &enum nvme_dsm_attributes + * @nr_ranges: Number of block ranges in the data set management attributes + */ +struct nvme_dsm_args { + __u32 *result; + struct nvme_dsm_range *dsm; + int args_size; + int fd; + __u32 timeout; + __u32 nsid; + __u32 attrs; + __u16 nr_ranges; +}; + +/** + * nvme_dsm() - Send an nvme data set management command + * @args: &struct nvme_dsm_args argument structure + * + * The Dataset Management command is used by the host to indicate attributes + * for ranges of logical blocks. This includes attributes like frequency that + * data is read or written, access size, and other information that may be used + * to optimize performance and reliability, and may be used to + * deallocate/unmap/trim those logical blocks. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_dsm(struct nvme_dsm_args *args); + +/** + * struct nvme_copy_args - Arguments for the NVMe Copy command + * @sdlba: Start destination LBA + * @result: The command completion result from CQE dword0 + * @copy: Range descriptior + * @args_size: Size of &struct nvme_copy_args + * @fd: File descriptor of the nvme device + * @timeout: Timeout in ms + * @nsid: Namespace identifier + * @ilbrt: Initial logical block reference tag + * @lr: Limited retry + * @fua: Force unit access + * @nr: Number of ranges + * @dspec: Directive specific value + * @lbatm: Logical block application tag mask + * @lbat: Logical block application tag + * @prinfor: Protection information field for read + * @prinfow: Protection information field for write + * @dtype: Directive type + * @format: Descriptor format + */ +struct nvme_copy_args { + __u64 sdlba; + __u32 *result; + struct nvme_copy_range *copy; + int args_size; + int fd; + __u32 timeout; + __u32 nsid; + __u32 ilbrt; + int lr; + int fua; + __u16 nr; + __u16 dspec; + __u16 lbatm; + __u16 lbat; + __u8 prinfor; + __u8 prinfow; + __u8 dtype; + __u8 format; +}; + +/** + * nvme_copy() - + * + * @args: &struct nvme_copy_args argument structure + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_copy(struct nvme_copy_args *args); + +/** + * struct nvme_resv_acquire_args - Arguments for the NVMe Reservation Acquire Comand + * @nrkey: The reservation key to be unregistered from the namespace if + * the action is preempt + * @iekey: Set to ignore the existing key + * @result: The command completion result from CQE dword0 + * @args_size: Size of &struct nvme_resv_acquire_args + * @fd: File descriptor of nvme device + * @timeout: Timeout in ms + * @nsid: Namespace identifier + * @rtype: The type of reservation to be create, see &enum nvme_resv_rtype + * @racqa: The action that is performed by the command, see &enum nvme_resv_racqa + * @crkey: The current reservation key associated with the host + */ +struct nvme_resv_acquire_args { + __u64 crkey; + __u64 nrkey; + __u32 *result; + int args_size; + int fd; + __u32 timeout; + __u32 nsid; + enum nvme_resv_rtype rtype; + enum nvme_resv_racqa racqa; + bool iekey; +}; + +/** + * nvme_resv_acquire() - Send an nvme reservation acquire + * @args: &struct nvme_resv_acquire argument structure + * + * The Reservation Acquire command acquires a reservation on a namespace, + * preempt a reservation held on a namespace, and abort a reservation held on a + * namespace. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_resv_acquire(struct nvme_resv_acquire_args *args); + +/** + * struct nvme_resv_register_args - Arguments for the NVMe Reservation Register command + * @crkey: The current reservation key associated with the host + * @nrkey: The new reservation key to be register if action is register or + * replace + * @result: The command completion result from CQE dword0 + * @args_size: Size of &struct nvme_resv_register_args + * @fd: File descriptor of nvme device + * @nsid: Namespace identifier + * @rrega: The registration action, see &enum nvme_resv_rrega + * @cptpl: Change persist through power loss, see &enum nvme_resv_cptpl + * @iekey: Set to ignore the existing key + * @timeout: Timeout in ms + */ +struct nvme_resv_register_args { + __u64 crkey; + __u64 nrkey; + __u32 *result; + int args_size; + int fd; + __u32 timeout; + __u32 nsid; + enum nvme_resv_rrega rrega; + enum nvme_resv_cptpl cptpl; + bool iekey; +}; + +/** + * nvme_resv_register() - Send an nvme reservation register + * @args: &struct nvme_resv_register_args argument structure + * + * The Reservation Register command registers, unregisters, or replaces a + * reservation key. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_resv_register(struct nvme_resv_register_args *args); + +/** + * struct nvme_resv_release_args - Arguments for the NVMe Reservation Release Command + * @crkey: The current reservation key to release + * @result: The command completion result from CQE dword0 + * @args_size: Size of &struct nvme_resv_release_args + * @fd: File descriptor of nvme device + * @timeout: Timeout in ms + * @nsid: Namespace identifier + * @rtype: The type of reservation to be create, see &enum nvme_resv_rtype + * @rrela: Reservation releast action, see &enum nvme_resv_rrela + * @iekey: Set to ignore the existing key + */ +struct nvme_resv_release_args { + __u64 crkey; + __u32 *result; + int args_size; + int fd; + __u32 timeout; + __u32 nsid; + enum nvme_resv_rtype rtype; + enum nvme_resv_rrela rrela; + bool iekey; +}; + +/** + * nvme_resv_release() - Send an nvme reservation release + * @args: &struct nvme_resv_release_args argument structure + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_resv_release(struct nvme_resv_release_args *args); + +/** + * struct nvme_resv_report_args - Arguments for the NVMe Reservation Report command + * @result: The command completion result from CQE dword0 + * @report: The user space destination address to store the reservation + * report + * @args_size: Size of &struct nvme_resv_report_args + * @fd: File descriptor of nvme device + * @timeout: Timeout in ms + * @nsid: Namespace identifier + * @len: Number of bytes to request transfered with this command + * @eds: Request extended Data Structure + */ +struct nvme_resv_report_args { + __u32 *result; + struct nvme_resv_status *report; + int args_size; + int fd; + __u32 timeout; + __u32 nsid; + __u32 len; + bool eds; +}; + +/** + * nvme_resv_report() - Send an nvme reservation report + * @args: struct nvme_resv_report_args argument structure + * + * Returns a Reservation Status data structure to memory that describes the + * registration and reservation status of a namespace. See the defintion for + * the returned structure, &struct nvme_reservation_status, for more details. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_resv_report(struct nvme_resv_report_args *args); + +/** + * struct nvme_zns_mgmt_send_args - Arguments for the NVMe ZNS Management Send command + * @slba: Starting logical block address + * @result: The command completion result from CQE dword0 + * @data: Userspace address of the data + * @args_size: Size of &struct nvme_zns_mgmt_send_args + * @fd: File descriptor of nvme device + * @timeout: timeout in ms + * @nsid: Namespace ID + * @zsa: Zone send action + * @data_len: Length of @data + * @select_all: Select all flag + * @zsaso: Zone Send Action Specific Option + */ +struct nvme_zns_mgmt_send_args { + __u64 slba; + __u32 *result; + void *data; + int args_size; + int fd; + __u32 timeout; + __u32 nsid; + enum nvme_zns_send_action zsa; + __u32 data_len; + bool select_all; + __u8 zsaso; +}; + +/** + * nvme_zns_mgmt_send() - + * @args: &struct nvme_zns_mgmt_send_args argument structure + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_zns_mgmt_send(struct nvme_zns_mgmt_send_args *args); + + +/** + * struct nvme_zns_mgmt_recv_args - Arguments for the NVMe ZNS Management Receive command + * @slba: Starting logical block address + * @result: The command completion result from CQE dword0 + * @data: Userspace address of the data + * @args_size: Size of &struct nvme_zns_mgmt_recv_args + * @fd: File descriptor of nvme device + * @timeout: timeout in ms + * @nsid: Namespace ID + * @zra: zone receive action + * @data_len: Length of @data + * @zrasf: Zone receive action specific field + * @zras_feat: Zone receive action specific features + */ +struct nvme_zns_mgmt_recv_args { + __u64 slba; + __u32 *result; + void *data; + int args_size; + int fd; + __u32 timeout; + __u32 nsid; + enum nvme_zns_recv_action zra; + __u32 data_len; + __u16 zrasf; + bool zras_feat; +}; + +/** + * nvme_zns_mgmt_recv() - + * @args: &struct nvme_zns_mgmt_recv_args argument structure + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_zns_mgmt_recv(struct nvme_zns_mgmt_recv_args *args); + +/** + * nvme_zns_report_zones() - Return the list of zones + * @fd: File descriptor of nvme device + * @nsid: Namespace ID + * @slba: Starting LBA + * @opts: Reporting options + * @extended: Extended report + * @partial: Partial report requested + * @data_len: Length of the data buffer + * @data: Userspace address of the report zones data + * @timeout: timeout in ms + * @result: The command completion result from CQE dword0 + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +static inline int nvme_zns_report_zones(int fd, __u32 nsid, __u64 slba, + enum nvme_zns_report_options opts, + bool extended, bool partial, + __u32 data_len, void *data, + __u32 timeout, __u32 *result) +{ + struct nvme_zns_mgmt_recv_args args = { + .slba = slba, + .result = result, + .data = data, + .args_size = sizeof(args), + .fd = fd, + .timeout = timeout, + .nsid = nsid, + .zra = extended ? NVME_ZNS_ZRA_EXTENDED_REPORT_ZONES : + NVME_ZNS_ZRA_REPORT_ZONES, + .data_len = data_len, + .zrasf = opts, + .zras_feat = partial, + }; + + return nvme_zns_mgmt_recv(&args); +} + +/** + * struct nvme_zns_append_args - Arguments for the NVMe ZNS Append command + * @zslba: Zone start logical block address + * @result: The command completion result from CQE dword0 + * @data: Userspace address of the data + * @metadata: Userspace address of the metadata + * @args_size: Size of &struct nvme_zns_append_args + * @fd: File descriptor of nvme device + * @timeout: Timeout in ms + * @nsid: Namespace ID + * @ilbrt: Initial logical block reference tag + * @data_len: Length of @data + * @metadata_len: Length of @metadata + * @nlb: Number of logical blocks + * @control: + * @lbat: Logical block application tag + * @lbatm: Logical block application tag mask + */ +struct nvme_zns_append_args { + __u64 zslba; + __u64 *result; + void *data; + void *metadata; + int args_size; + int fd; + __u32 timeout; + __u32 nsid; + __u32 ilbrt; + __u32 data_len; + __u32 metadata_len; + __u16 nlb; + __u16 control; + __u16 lbat; + __u16 lbatm; +}; + +/** + * nvme_zns_append() - Append data to a zone + * @args: &struct nvme_zns_append_args argument structure + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_zns_append(struct nvme_zns_append_args *args); + +/** + * struct nvme_dim_args - Arguments for the Discovery Information Management (DIM) command + * @result: Set on completion to the command's CQE DWORD 0 controller response. + * @data: Pointer to the DIM data + * @args_size: Length of the structure + * @fd: File descriptor of nvme device + * @timeout: Timeout in ms + * @data_len: Length of @data + * @tas: Task field of the Command Dword 10 (cdw10) + */ +struct nvme_dim_args { + __u32 *result; + void *data; + int args_size; + int fd; + __u32 timeout; + __u32 data_len; + __u8 tas; +}; + +/** + * nvme_dim_send - Send a Discovery Information Management (DIM) command + * @args: &struct nvme_dim_args argument structure + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_dim_send(struct nvme_dim_args *args); + +#endif /* _LIBNVME_IOCTL_H */ diff --git a/src/nvme/json.c b/src/nvme/json.c new file mode 100644 index 0000000..6f0b81c --- /dev/null +++ b/src/nvme/json.c @@ -0,0 +1,466 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/* + * This file is part of libnvme. + * Copyright (c) 2021 SUSE Software Solutions + * + * Authors: Hannes Reinecke <hare@suse.de> + */ + +#include <stdio.h> +#include <errno.h> +#include <string.h> +#include <unistd.h> +#include <fcntl.h> + +#include <json.h> + +#include "fabrics.h" +#include "log.h" +#include "private.h" + +#define JSON_UPDATE_INT_OPTION(c, k, a, o) \ + if (!strcmp(# a, k ) && !c->a) c->a = json_object_get_int(o); +#define JSON_UPDATE_BOOL_OPTION(c, k, a, o) \ + if (!strcmp(# a, k ) && !c->a) c->a = json_object_get_boolean(o); + +static void json_update_attributes(nvme_ctrl_t c, + struct json_object *ctrl_obj) +{ + struct nvme_fabrics_config *cfg = nvme_ctrl_get_config(c); + + json_object_object_foreach(ctrl_obj, key_str, val_obj) { + JSON_UPDATE_INT_OPTION(cfg, key_str, + nr_io_queues, val_obj); + JSON_UPDATE_INT_OPTION(cfg, key_str, + nr_write_queues, val_obj); + JSON_UPDATE_INT_OPTION(cfg, key_str, + nr_poll_queues, val_obj); + JSON_UPDATE_INT_OPTION(cfg, key_str, + queue_size, val_obj); + JSON_UPDATE_INT_OPTION(cfg, key_str, + keep_alive_tmo, val_obj); + JSON_UPDATE_INT_OPTION(cfg, key_str, + reconnect_delay, val_obj); + if (!strcmp("ctrl_loss_tmo", key_str) && + cfg->ctrl_loss_tmo != NVMF_DEF_CTRL_LOSS_TMO) + cfg->ctrl_loss_tmo = json_object_get_int(val_obj); + JSON_UPDATE_INT_OPTION(cfg, key_str, + fast_io_fail_tmo, val_obj); + if (!strcmp("tos", key_str) && cfg->tos != -1) + cfg->tos = json_object_get_int(val_obj); + JSON_UPDATE_BOOL_OPTION(cfg, key_str, + duplicate_connect, val_obj); + JSON_UPDATE_BOOL_OPTION(cfg, key_str, + disable_sqflow, val_obj); + JSON_UPDATE_BOOL_OPTION(cfg, key_str, + hdr_digest, val_obj); + JSON_UPDATE_BOOL_OPTION(cfg, key_str, + data_digest, val_obj); + JSON_UPDATE_BOOL_OPTION(cfg, key_str, + tls, val_obj); + if (!strcmp("persistent", key_str) && + !nvme_ctrl_is_persistent(c)) + nvme_ctrl_set_persistent(c, true); + if (!strcmp("discovery", key_str) && + !nvme_ctrl_is_discovery_ctrl(c)) + nvme_ctrl_set_discovery_ctrl(c, true); + } +} + +static void json_parse_port(nvme_subsystem_t s, struct json_object *port_obj) +{ + nvme_ctrl_t c; + struct json_object *attr_obj; + const char *transport, *traddr = NULL; + const char *host_traddr = NULL, *host_iface = NULL, *trsvcid = NULL; + + attr_obj = json_object_object_get(port_obj, "transport"); + if (!attr_obj) + return; + transport = json_object_get_string(attr_obj); + attr_obj = json_object_object_get(port_obj, "traddr"); + if (attr_obj) + traddr = json_object_get_string(attr_obj); + attr_obj = json_object_object_get(port_obj, "host_traddr"); + if (attr_obj) + host_traddr = json_object_get_string(attr_obj); + attr_obj = json_object_object_get(port_obj, "host_iface"); + if (attr_obj) + host_iface = json_object_get_string(attr_obj); + attr_obj = json_object_object_get(port_obj, "trsvcid"); + if (attr_obj) + trsvcid = json_object_get_string(attr_obj); + c = nvme_lookup_ctrl(s, transport, traddr, host_traddr, + host_iface, trsvcid, NULL); + if (!c) + return; + json_update_attributes(c, port_obj); + attr_obj = json_object_object_get(port_obj, "dhchap_key"); + if (attr_obj) + nvme_ctrl_set_dhchap_key(c, json_object_get_string(attr_obj)); +} + +static void json_parse_subsys(nvme_host_t h, struct json_object *subsys_obj) +{ + struct json_object *nqn_obj, *port_array; + nvme_subsystem_t s; + const char *nqn; + int p; + + nqn_obj = json_object_object_get(subsys_obj, "nqn"); + if (!nqn_obj) + return; + nqn = json_object_get_string(nqn_obj); + s = nvme_lookup_subsystem(h, NULL, nqn); + port_array = json_object_object_get(subsys_obj, "ports"); + if (!port_array) + return; + for (p = 0; p < json_object_array_length(port_array); p++) { + struct json_object *port_obj; + + port_obj = json_object_array_get_idx(port_array, p); + if (port_obj) + json_parse_port(s, port_obj); + } +} + +static void json_parse_host(nvme_root_t r, struct json_object *host_obj) +{ + struct json_object *attr_obj, *subsys_array, *subsys_obj; + nvme_host_t h; + const char *hostnqn, *hostid = NULL; + int s; + + attr_obj = json_object_object_get(host_obj, "hostnqn"); + if (!attr_obj) + return; + hostnqn = json_object_get_string(attr_obj); + attr_obj = json_object_object_get(host_obj, "hostid"); + if (attr_obj) + hostid = json_object_get_string(attr_obj); + h = nvme_lookup_host(r, hostnqn, hostid); + attr_obj = json_object_object_get(host_obj, "dhchap_key"); + if (attr_obj) + nvme_host_set_dhchap_key(h, json_object_get_string(attr_obj)); + attr_obj = json_object_object_get(host_obj, "hostsymname"); + if (attr_obj) + nvme_host_set_hostsymname(h, json_object_get_string(attr_obj)); + subsys_array = json_object_object_get(host_obj, "subsystems"); + if (!subsys_array) + return; + for (s = 0; s < json_object_array_length(subsys_array); s++) { + subsys_obj = json_object_array_get_idx(subsys_array, s); + if (subsys_obj) + json_parse_subsys(h, subsys_obj); + } +} + +int json_read_config(nvme_root_t r, const char *config_file) +{ + struct json_object *json_root, *host_obj; + int fd, h; + + fd = open(config_file, O_RDONLY); + if (fd < 0) { + nvme_msg(r, LOG_DEBUG, "Error opening %s, %s\n", + config_file, strerror(errno)); + return fd; + } + json_root = json_object_from_fd(fd); + if (!json_root) { + nvme_msg(r, LOG_DEBUG, "Failed to read %s, %s\n", + config_file, json_util_get_last_err()); + errno = EPROTO; + close(fd); + return -1; + } + for (h = 0; h < json_object_array_length(json_root); h++) { + host_obj = json_object_array_get_idx(json_root, h); + if (host_obj) + json_parse_host(r, host_obj); + } + json_object_put(json_root); + close(fd); + return 0; +} + +#define JSON_STRING_OPTION(c, p, o) \ + if ((c)->o && strcmp((c)->o, "none")) \ + json_object_object_add((p), # o , \ + json_object_new_string((c)->o)) +#define JSON_INT_OPTION(c, p, o, d) \ + if ((c)->o != d) \ + json_object_object_add((p), # o , \ + json_object_new_int((c)->o)) +#define JSON_BOOL_OPTION(c, p, o) \ + if ((c)->o) \ + json_object_object_add((p), # o , \ + json_object_new_boolean((c)->o)) + +static void json_update_port(struct json_object *ctrl_array, nvme_ctrl_t c) +{ + struct nvme_fabrics_config *cfg = nvme_ctrl_get_config(c); + struct json_object *port_obj = json_object_new_object(); + const char *transport, *value; + + transport = nvme_ctrl_get_transport(c); + json_object_object_add(port_obj, "transport", + json_object_new_string(transport)); + value = nvme_ctrl_get_traddr(c); + if (value) + json_object_object_add(port_obj, "traddr", + json_object_new_string(value)); + value = nvme_ctrl_get_host_traddr(c); + if (value) + json_object_object_add(port_obj, "host_traddr", + json_object_new_string(value)); + value = nvme_ctrl_get_host_iface(c); + if (value) + json_object_object_add(port_obj, "host_iface", + json_object_new_string(value)); + value = nvme_ctrl_get_trsvcid(c); + if (value) + json_object_object_add(port_obj, "trsvcid", + json_object_new_string(value)); + value = nvme_ctrl_get_dhchap_key(c); + if (value) + json_object_object_add(port_obj, "dhchap_key", + json_object_new_string(value)); + JSON_INT_OPTION(cfg, port_obj, nr_io_queues, 0); + JSON_INT_OPTION(cfg, port_obj, nr_write_queues, 0); + JSON_INT_OPTION(cfg, port_obj, nr_poll_queues, 0); + JSON_INT_OPTION(cfg, port_obj, queue_size, 0); + JSON_INT_OPTION(cfg, port_obj, keep_alive_tmo, 0); + JSON_INT_OPTION(cfg, port_obj, reconnect_delay, 0); + if (strcmp(transport, "loop")) { + JSON_INT_OPTION(cfg, port_obj, ctrl_loss_tmo, + NVMF_DEF_CTRL_LOSS_TMO); + JSON_INT_OPTION(cfg, port_obj, fast_io_fail_tmo, 0); + } + JSON_INT_OPTION(cfg, port_obj, tos, -1); + JSON_BOOL_OPTION(cfg, port_obj, duplicate_connect); + JSON_BOOL_OPTION(cfg, port_obj, disable_sqflow); + JSON_BOOL_OPTION(cfg, port_obj, hdr_digest); + JSON_BOOL_OPTION(cfg, port_obj, data_digest); + JSON_BOOL_OPTION(cfg, port_obj, tls); + if (nvme_ctrl_is_persistent(c)) + json_object_object_add(port_obj, "persistent", + json_object_new_boolean(true)); + if (nvme_ctrl_is_discovery_ctrl(c)) + json_object_object_add(port_obj, "discovery", + json_object_new_boolean(true)); + json_object_array_add(ctrl_array, port_obj); +} + +static void json_update_subsys(struct json_object *subsys_array, + nvme_subsystem_t s) +{ + nvme_ctrl_t c; + const char *subsysnqn = nvme_subsystem_get_nqn(s); + struct json_object *subsys_obj = json_object_new_object(); + struct json_object *port_array; + + /* Skip discovery subsystems as the nqn is not unique */ + if (!strcmp(subsysnqn, NVME_DISC_SUBSYS_NAME)) + return; + + json_object_object_add(subsys_obj, "nqn", + json_object_new_string(subsysnqn)); + port_array = json_object_new_array(); + nvme_subsystem_for_each_ctrl(s, c) { + json_update_port(port_array, c); + } + if (json_object_array_length(port_array)) + json_object_object_add(subsys_obj, "ports", port_array); + else + json_object_put(port_array); + json_object_array_add(subsys_array, subsys_obj); +} + +int json_update_config(nvme_root_t r, const char *config_file) +{ + nvme_host_t h; + struct json_object *json_root, *host_obj; + struct json_object *subsys_array; + int ret = 0; + + json_root = json_object_new_array(); + nvme_for_each_host(r, h) { + nvme_subsystem_t s; + const char *hostnqn, *hostid, *dhchap_key, *hostsymname; + + host_obj = json_object_new_object(); + if (!host_obj) + continue; + hostnqn = nvme_host_get_hostnqn(h); + json_object_object_add(host_obj, "hostnqn", + json_object_new_string(hostnqn)); + hostid = nvme_host_get_hostid(h); + if (hostid) + json_object_object_add(host_obj, "hostid", + json_object_new_string(hostid)); + dhchap_key = nvme_host_get_dhchap_key(h); + if (dhchap_key) + json_object_object_add(host_obj, "dhchap_key", + json_object_new_string(dhchap_key)); + hostsymname = nvme_host_get_hostsymname(h); + if (hostsymname) + json_object_object_add(host_obj, "hostsymname", + json_object_new_string(hostsymname)); + subsys_array = json_object_new_array(); + nvme_for_each_subsystem(h, s) { + json_update_subsys(subsys_array, s); + } + if (json_object_array_length(subsys_array)) + json_object_object_add(host_obj, "subsystems", + subsys_array); + else + json_object_put(subsys_array); + json_object_array_add(json_root, host_obj); + } + if (!config_file) + ret = json_object_to_fd(1, json_root, JSON_C_TO_STRING_PRETTY); + else + ret = json_object_to_file_ext(config_file, json_root, + JSON_C_TO_STRING_PRETTY); + if (ret < 0) { + nvme_msg(r, LOG_ERR, "Failed to write to %s, %s\n", + config_file ? "stdout" : config_file, + json_util_get_last_err()); + ret = -1; + errno = EIO; + } + json_object_put(json_root); + + return ret; +} + +static void json_dump_ctrl(struct json_object *ctrl_array, nvme_ctrl_t c) +{ + struct nvme_fabrics_config *cfg = nvme_ctrl_get_config(c); + struct json_object *ctrl_obj = json_object_new_object(); + const char *name, *transport, *value; + + name = nvme_ctrl_get_name(c); + if (name && strlen(name)) + json_object_object_add(ctrl_obj, "name", + json_object_new_string(name)); + transport = nvme_ctrl_get_transport(c); + json_object_object_add(ctrl_obj, "transport", + json_object_new_string(transport)); + value = nvme_ctrl_get_traddr(c); + if (value) + json_object_object_add(ctrl_obj, "traddr", + json_object_new_string(value)); + value = nvme_ctrl_get_host_traddr(c); + if (value) + json_object_object_add(ctrl_obj, "host_traddr", + json_object_new_string(value)); + value = nvme_ctrl_get_host_iface(c); + if (value) + json_object_object_add(ctrl_obj, "host_iface", + json_object_new_string(value)); + value = nvme_ctrl_get_trsvcid(c); + if (value) + json_object_object_add(ctrl_obj, "trsvcid", + json_object_new_string(value)); + value = nvme_ctrl_get_dhchap_key(c); + if (value) + json_object_object_add(ctrl_obj, "dhchap_key", + json_object_new_string(value)); + JSON_INT_OPTION(cfg, ctrl_obj, nr_io_queues, 0); + JSON_INT_OPTION(cfg, ctrl_obj, nr_write_queues, 0); + JSON_INT_OPTION(cfg, ctrl_obj, nr_poll_queues, 0); + JSON_INT_OPTION(cfg, ctrl_obj, queue_size, 0); + JSON_INT_OPTION(cfg, ctrl_obj, keep_alive_tmo, 0); + JSON_INT_OPTION(cfg, ctrl_obj, reconnect_delay, 0); + if (strcmp(transport, "loop")) { + JSON_INT_OPTION(cfg, ctrl_obj, ctrl_loss_tmo, + NVMF_DEF_CTRL_LOSS_TMO); + JSON_INT_OPTION(cfg, ctrl_obj, fast_io_fail_tmo, 0); + } + JSON_INT_OPTION(cfg, ctrl_obj, tos, -1); + JSON_BOOL_OPTION(cfg, ctrl_obj, duplicate_connect); + JSON_BOOL_OPTION(cfg, ctrl_obj, disable_sqflow); + JSON_BOOL_OPTION(cfg, ctrl_obj, hdr_digest); + JSON_BOOL_OPTION(cfg, ctrl_obj, data_digest); + JSON_BOOL_OPTION(cfg, ctrl_obj, tls); + if (nvme_ctrl_is_persistent(c)) + json_object_object_add(ctrl_obj, "persistent", + json_object_new_boolean(true)); + if (nvme_ctrl_is_discovery_ctrl(c)) + json_object_object_add(ctrl_obj, "discovery", + json_object_new_boolean(true)); + json_object_array_add(ctrl_array, ctrl_obj); +} + +static void json_dump_subsys(struct json_object *subsys_array, + nvme_subsystem_t s) +{ + nvme_ctrl_t c; + struct json_object *subsys_obj = json_object_new_object(); + struct json_object *ctrl_array; + + json_object_object_add(subsys_obj, "name", + json_object_new_string(nvme_subsystem_get_name(s))); + json_object_object_add(subsys_obj, "nqn", + json_object_new_string(nvme_subsystem_get_nqn(s))); + ctrl_array = json_object_new_array(); + nvme_subsystem_for_each_ctrl(s, c) { + json_dump_ctrl(ctrl_array, c); + } + if (json_object_array_length(ctrl_array)) + json_object_object_add(subsys_obj, "controllers", ctrl_array); + else + json_object_put(ctrl_array); + json_object_array_add(subsys_array, subsys_obj); +} + +int json_dump_tree(nvme_root_t r) +{ + nvme_host_t h; + struct json_object *json_root, *host_obj; + struct json_object *host_array, *subsys_array; + int ret = 0; + + json_root = json_object_new_object(); + host_array = json_object_new_array(); + nvme_for_each_host(r, h) { + nvme_subsystem_t s; + const char *hostid, *dhchap_key; + + host_obj = json_object_new_object(); + json_object_object_add(host_obj, "hostnqn", + json_object_new_string(nvme_host_get_hostnqn(h))); + hostid = nvme_host_get_hostid(h); + if (hostid) + json_object_object_add(host_obj, "hostid", + json_object_new_string(hostid)); + dhchap_key = nvme_host_get_dhchap_key(h); + if (dhchap_key) + json_object_object_add(host_obj, "dhchap_key", + json_object_new_string(dhchap_key)); + subsys_array = json_object_new_array(); + nvme_for_each_subsystem(h, s) { + json_dump_subsys(subsys_array, s); + } + if (json_object_array_length(subsys_array)) + json_object_object_add(host_obj, "subsystems", + subsys_array); + else + json_object_put(subsys_array); + json_object_array_add(host_array, host_obj); + } + json_object_object_add(json_root, "hosts", host_array); + + ret = json_object_to_fd(1, json_root, JSON_C_TO_STRING_PRETTY); + if (ret < 0) { + nvme_msg(r, LOG_ERR, "Failed to write to stdout, %s\n", + json_util_get_last_err()); + ret = -1; + errno = EIO; + } + json_object_put(json_root); + + return ret; +} diff --git a/src/nvme/linux.c b/src/nvme/linux.c new file mode 100644 index 0000000..c9b6bbf --- /dev/null +++ b/src/nvme/linux.c @@ -0,0 +1,679 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/* + * This file is part of libnvme. + * Copyright (c) 2020 Western Digital Corporation or its affiliates. + * + * Authors: Keith Busch <keith.busch@wdc.com> + * Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com> + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <errno.h> + +#include <sys/param.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <unistd.h> + +#ifdef CONFIG_OPENSSL +#include <openssl/engine.h> +#include <openssl/evp.h> +#include <openssl/hmac.h> + +#ifdef CONFIG_OPENSSL_3 +#include <openssl/core_names.h> +#include <openssl/params.h> +#endif +#endif + +#include <ccan/endian/endian.h> + +#include "linux.h" +#include "tree.h" +#include "log.h" +#include "private.h" + +static int __nvme_open(const char *name) +{ + char *path; + int fd, ret; + + ret = asprintf(&path, "%s/%s", "/dev", name); + if (ret < 0) { + errno = ENOMEM; + return -1; + } + + fd = open(path, O_RDONLY); + free(path); + return fd; +} + +int nvme_open(const char *name) +{ + int ret, fd, id, ns; + struct stat stat; + bool c; + + ret = sscanf(name, "nvme%dn%d", &id, &ns); + if (ret != 1 && ret != 2) { + errno = EINVAL; + return -1; + } + c = ret == 1; + + fd = __nvme_open(name); + if (fd < 0) + return fd; + + ret = fstat(fd, &stat); + if (ret < 0) + goto close_fd; + + if (c) { + if (!S_ISCHR(stat.st_mode)) { + errno = EINVAL; + goto close_fd; + } + } else if (!S_ISBLK(stat.st_mode)) { + errno = EINVAL; + goto close_fd; + } + + return fd; + +close_fd: + close(fd); + return -1; +} + +int nvme_fw_download_seq(int fd, __u32 size, __u32 xfer, __u32 offset, + void *buf) +{ + int err = 0; + struct nvme_fw_download_args args = { + .args_size = sizeof(args), + .fd = fd, + .offset = offset, + .data_len = xfer, + .data = buf, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = NULL, + }; + + while (size > 0) { + args.data_len = MIN(xfer, size); + err = nvme_fw_download(&args); + if (err) + break; + + args.data += xfer; + size -= xfer; + args.offset += xfer; + } + + return err; +} + +int nvme_get_log_page(int fd, __u32 xfer_len, struct nvme_get_log_args *args) +{ + __u64 offset = 0, xfer, data_len = args->len; + bool retain = true; + void *ptr = args->log; + int ret; + + /* + * 4k is the smallest possible transfer unit, so restricting to 4k + * avoids having to check the MDTS value of the controller. + */ + do { + xfer = data_len - offset; + if (xfer > xfer_len) + xfer = xfer_len; + + /* + * Always retain regardless of the RAE parameter until the very + * last portion of this log page so the data remains latched + * during the fetch sequence. + */ + if (offset + xfer == data_len) + retain = args->rae; + + args->lpo = offset; + args->len = xfer; + args->log = ptr; + args->rae = retain; + ret = nvme_get_log(args); + if (ret) + return ret; + + offset += xfer; + ptr += xfer; + } while (offset < data_len); + + return 0; +} + +static int nvme_get_telemetry_log(int fd, bool create, bool ctrl, bool rae, + struct nvme_telemetry_log **buf, enum nvme_telemetry_da da, + size_t *size) +{ + static const __u32 xfer = NVME_LOG_TELEM_BLOCK_SIZE; + + struct nvme_telemetry_log *telem; + enum nvme_cmd_get_log_lid lid; + struct nvme_id_ctrl id_ctrl; + void *log, *tmp; + int err; + struct nvme_get_log_args args = { + .args_size = sizeof(args), + .fd = fd, + .nsid = NVME_NSID_NONE, + .lsp = NVME_LOG_LSP_NONE, + .lsi = NVME_LOG_LSI_NONE, + .uuidx = NVME_UUID_NONE, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = NULL, + .csi = NVME_CSI_NVM, + .rae = rae, + .ot = false, + }; + + *size = 0; + + log = malloc(xfer); + if (!log) { + errno = ENOMEM; + return -1; + } + + if (ctrl) { + err = nvme_get_log_telemetry_ctrl(fd, true, 0, xfer, log); + lid = NVME_LOG_LID_TELEMETRY_CTRL; + } else { + lid = NVME_LOG_LID_TELEMETRY_HOST; + if (create) + err = nvme_get_log_create_telemetry_host(fd, log); + else + err = nvme_get_log_telemetry_host(fd, 0, xfer, log); + } + + if (err) + goto free; + + telem = log; + if (ctrl && !telem->ctrlavail) { + *buf = log; + *size = xfer; + return 0; + } + + switch (da) { + case NVME_TELEMETRY_DA_1: + case NVME_TELEMETRY_DA_2: + case NVME_TELEMETRY_DA_3: + /* dalb3 >= dalb2 >= dalb1 */ + *size = (le16_to_cpu(telem->dalb3) + 1) * xfer; + break; + case NVME_TELEMETRY_DA_4: + err = nvme_identify_ctrl(fd, &id_ctrl); + if (err) { + perror("identify-ctrl"); + errno = EINVAL; + goto free; + } + + if (id_ctrl.lpa & 0x40) { + *size = (le32_to_cpu(telem->dalb4) + 1) * xfer; + } else { + fprintf(stderr, "Data area 4 unsupported, bit 6 of Log Page Attributes not set\n"); + errno = EINVAL; + err = -1; + goto free; + } + break; + default: + fprintf(stderr, "Invalid data area parameter - %d\n", da); + errno = EINVAL; + err = -1; + goto free; + } + + tmp = realloc(log, *size); + if (!tmp) { + errno = ENOMEM; + err = -1; + goto free; + } + log = tmp; + + args.lid = lid; + args.log = log; + args.len = *size; + err = nvme_get_log_page(fd, 4096, &args); + if (!err) { + *buf = log; + return 0; + } +free: + free(log); + return err; +} + +int nvme_get_ctrl_telemetry(int fd, bool rae, struct nvme_telemetry_log **log, + enum nvme_telemetry_da da, size_t *size) +{ + return nvme_get_telemetry_log(fd, false, true, rae, log, da, size); +} + +int nvme_get_host_telemetry(int fd, struct nvme_telemetry_log **log, + enum nvme_telemetry_da da, size_t *size) +{ + return nvme_get_telemetry_log(fd, false, false, false, log, da, size); +} + +int nvme_get_new_host_telemetry(int fd, struct nvme_telemetry_log **log, + enum nvme_telemetry_da da, size_t *size) +{ + return nvme_get_telemetry_log(fd, true, false, false, log, da, size); +} + +int nvme_get_lba_status_log(int fd, bool rae, struct nvme_lba_status_log **log) +{ + __u32 size = sizeof(struct nvme_lba_status_log); + void *buf, *tmp; + int err; + struct nvme_get_log_args args = { + .args_size = sizeof(args), + .fd = fd, + .nsid = NVME_NSID_NONE, + .lsp = NVME_LOG_LSP_NONE, + .lsi = NVME_LOG_LSI_NONE, + .uuidx = NVME_UUID_NONE, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = NULL, + .csi = NVME_CSI_NVM, + .rae = rae, + .ot = false, + }; + + buf = malloc(size); + if (!buf) + return -1; + + *log = buf; + err = nvme_get_log_lba_status(fd, true, 0, size, buf); + if (err) + goto free; + + size = le32_to_cpu((*log)->lslplen); + if (!size) + return 0; + + tmp = realloc(buf, size); + if (!tmp) { + err = -1; + goto free; + } + buf = tmp; + *log = buf; + + args.lid = NVME_LOG_LID_LBA_STATUS; + args.log = buf; + args.len = size; + err = nvme_get_log_page(fd, 4096, &args); + if (!err) + return 0; + +free: + *log = NULL; + free(buf); + return err; +} + +static int nvme_ns_attachment(int fd, __u32 nsid, __u16 num_ctrls, + __u16 *ctrlist, bool attach, __u32 timeout) +{ + struct nvme_ctrl_list cntlist = { 0 }; + struct nvme_ns_attach_args args = { + .args_size = sizeof(args), + .fd = fd, + .nsid = nsid, + .sel = NVME_NS_ATTACH_SEL_CTRL_DEATTACH, + .ctrlist = &cntlist, + .timeout = timeout, + }; + + if (attach) + args.sel = NVME_NS_ATTACH_SEL_CTRL_ATTACH; + + nvme_init_ctrl_list(args.ctrlist, num_ctrls, ctrlist); + return nvme_ns_attach(&args); +} + +int nvme_namespace_attach_ctrls(int fd, __u32 nsid, __u16 num_ctrls, + __u16 *ctrlist) +{ + return nvme_ns_attachment(fd, nsid, num_ctrls, ctrlist, true, + NVME_DEFAULT_IOCTL_TIMEOUT); +} + +int nvme_namespace_detach_ctrls(int fd, __u32 nsid, __u16 num_ctrls, + __u16 *ctrlist) +{ + return nvme_ns_attachment(fd, nsid, num_ctrls, ctrlist, false, + NVME_DEFAULT_IOCTL_TIMEOUT); +} + +int nvme_get_ana_log_len(int fd, size_t *analen) +{ + struct nvme_id_ctrl ctrl; + int ret; + + ret = nvme_identify_ctrl(fd, &ctrl); + if (ret) + return ret; + + *analen = sizeof(struct nvme_ana_log) + + le32_to_cpu(ctrl.nanagrpid) * sizeof(struct nvme_ana_group_desc) + + le32_to_cpu(ctrl.mnan) * sizeof(__le32); + return 0; +} + +int nvme_get_logical_block_size(int fd, __u32 nsid, int *blksize) +{ + struct nvme_id_ns ns; + __u8 flbas; + int ret; + + ret = nvme_identify_ns(fd, nsid, &ns); + if (ret) + return ret; + + nvme_id_ns_flbas_to_lbaf_inuse(ns.flbas, &flbas); + *blksize = 1 << ns.lbaf[flbas].ds; + + return 0; +} + +static int __nvme_set_attr(const char *path, const char *value) +{ + int ret, fd; + + fd = open(path, O_WRONLY); + if (fd < 0) { +#if 0 + nvme_msg(LOG_DEBUG, "Failed to open %s: %s\n", path, + strerror(errno)); +#endif + return -1; + } + ret = write(fd, value, strlen(value)); + close(fd); + return ret; +} + +int nvme_set_attr(const char *dir, const char *attr, const char *value) +{ + char *path; + int ret; + + ret = asprintf(&path, "%s/%s", dir, attr); + if (ret < 0) + return -1; + + ret = __nvme_set_attr(path, value); + free(path); + return ret; +} + +static char *__nvme_get_attr(const char *path) +{ + char value[4096] = { 0 }; + int ret, fd; + int saved_errno; + + fd = open(path, O_RDONLY); + if (fd < 0) + return NULL; + + ret = read(fd, value, sizeof(value) - 1); + saved_errno = errno; + close(fd); + if (ret < 0) { + errno = saved_errno; + return NULL; + } + errno = 0; + if (!strlen(value)) + return NULL; + + if (value[strlen(value) - 1] == '\n') + value[strlen(value) - 1] = '\0'; + while (strlen(value) > 0 && value[strlen(value) - 1] == ' ') + value[strlen(value) - 1] = '\0'; + + return strlen(value) ? strdup(value) : NULL; +} + +char *nvme_get_attr(const char *dir, const char *attr) +{ + char *path, *value; + int ret; + + ret = asprintf(&path, "%s/%s", dir, attr); + if (ret < 0) { + errno = ENOMEM; + return NULL; + } + + value = __nvme_get_attr(path); + free(path); + return value; +} + +char *nvme_get_subsys_attr(nvme_subsystem_t s, const char *attr) +{ + return nvme_get_attr(nvme_subsystem_get_sysfs_dir(s), attr); +} + +char *nvme_get_ctrl_attr(nvme_ctrl_t c, const char *attr) +{ + return nvme_get_attr(nvme_ctrl_get_sysfs_dir(c), attr); +} + +char *nvme_get_ns_attr(nvme_ns_t n, const char *attr) +{ + return nvme_get_attr(nvme_ns_get_sysfs_dir(n), attr); +} + +char *nvme_get_path_attr(nvme_path_t p, const char *attr) +{ + return nvme_get_attr(nvme_path_get_sysfs_dir(p), attr); +} + +#ifndef CONFIG_OPENSSL +int nvme_gen_dhchap_key(char *hostnqn, enum nvme_hmac_alg hmac, + unsigned int key_len, unsigned char *secret, + unsigned char *key) +{ + if (hmac != NVME_HMAC_ALG_NONE) { + nvme_msg(NULL, LOG_ERR, "HMAC transformation not supported; " \ + "recompile with OpenSSL support.\n"); + errno = -EINVAL; + return -1; + } + + memcpy(key, secret, key_len); + return 0; +} +#endif /* !CONFIG_OPENSSL */ + +#ifdef CONFIG_OPENSSL_1 +int nvme_gen_dhchap_key(char *hostnqn, enum nvme_hmac_alg hmac, + unsigned int key_len, unsigned char *secret, + unsigned char *key) +{ + const char hmac_seed[] = "NVMe-over-Fabrics"; + HMAC_CTX *hmac_ctx; + const EVP_MD *md; + int err = -1; + + ENGINE_load_builtin_engines(); + ENGINE_register_all_complete(); + + hmac_ctx = HMAC_CTX_new(); + if (!hmac_ctx) { + errno = ENOMEM; + return err; + } + + switch (hmac) { + case NVME_HMAC_ALG_NONE: + memcpy(key, secret, key_len); + err = 0; + goto out; + case NVME_HMAC_ALG_SHA2_256: + md = EVP_sha256(); + break; + case NVME_HMAC_ALG_SHA2_384: + md = EVP_sha384(); + break; + case NVME_HMAC_ALG_SHA2_512: + md = EVP_sha512(); + break; + default: + errno = EINVAL; + goto out; + } + + if (!md) { + errno = EINVAL; + goto out; + } + + if (!HMAC_Init_ex(hmac_ctx, secret, key_len, md, NULL)) { + errno = ENOMEM; + goto out; + } + + if (!HMAC_Update(hmac_ctx, (unsigned char *)hostnqn, + strlen(hostnqn))) { + errno = ENOKEY; + goto out; + } + + if (!HMAC_Update(hmac_ctx, (unsigned char *)hmac_seed, + strlen(hmac_seed))) { + errno = ENOKEY; + goto out; + } + + if (!HMAC_Final(hmac_ctx, key, &key_len)) { + errno = ENOKEY; + goto out; + } + + err = 0; + +out: + HMAC_CTX_free(hmac_ctx); + return err; +} +#endif /* !CONFIG_OPENSSL_1 */ + +#ifdef CONFIG_OPENSSL_3 +int nvme_gen_dhchap_key(char *hostnqn, enum nvme_hmac_alg hmac, + unsigned int key_len, unsigned char *secret, + unsigned char *key) +{ + const char hmac_seed[] = "NVMe-over-Fabrics"; + OSSL_PARAM params[2], *p = params; + OSSL_LIB_CTX *lib_ctx; + EVP_MAC_CTX *mac_ctx = NULL; + EVP_MAC *mac = NULL; + char *progq = NULL; + char *digest; + size_t len; + int err = -1; + + lib_ctx = OSSL_LIB_CTX_new(); + if (!lib_ctx) { + errno = ENOMEM; + return err; + } + + mac = EVP_MAC_fetch(lib_ctx, OSSL_MAC_NAME_HMAC, progq); + if (!mac) { + errno = ENOMEM; + goto out; + } + + mac_ctx = EVP_MAC_CTX_new(mac); + if (!mac_ctx) { + errno = ENOMEM; + goto out; + } + + switch (hmac) { + case NVME_HMAC_ALG_NONE: + memcpy(key, secret, key_len); + err = 0; + goto out; + case NVME_HMAC_ALG_SHA2_256: + digest = OSSL_DIGEST_NAME_SHA2_256; + break; + case NVME_HMAC_ALG_SHA2_384: + digest = OSSL_DIGEST_NAME_SHA2_384; + break; + case NVME_HMAC_ALG_SHA2_512: + digest = OSSL_DIGEST_NAME_SHA2_512; + break; + default: + errno = EINVAL; + goto out; + } + *p++ = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST, + digest, + 0); + *p = OSSL_PARAM_construct_end(); + + if (!EVP_MAC_init(mac_ctx, secret, key_len, params)) { + errno = ENOKEY; + goto out; + } + + if (!EVP_MAC_update(mac_ctx, (unsigned char *)hostnqn, + strlen(hostnqn))) { + errno = ENOKEY; + goto out; + } + + if (!EVP_MAC_update(mac_ctx, (unsigned char *)hmac_seed, + strlen(hmac_seed))) { + errno = ENOKEY; + goto out; + } + + if (!EVP_MAC_final(mac_ctx, key, &len, key_len)) { + errno = ENOKEY; + goto out; + } + + if (len != key_len) { + errno = EMSGSIZE; + goto out; + } + + err = 0; + +out: + EVP_MAC_CTX_free(mac_ctx); + EVP_MAC_free(mac); + OSSL_LIB_CTX_free(lib_ctx); + + return err; +} +#endif /* !CONFIG_OPENSSL_3 */ diff --git a/src/nvme/linux.h b/src/nvme/linux.h new file mode 100644 index 0000000..6223c0a --- /dev/null +++ b/src/nvme/linux.h @@ -0,0 +1,208 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/* + * This file is part of libnvme. + * Copyright (c) 2020 Western Digital Corporation or its affiliates. + * + * Authors: Keith Busch <keith.busch@wdc.com> + * Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com> + */ +#ifndef _LIBNVME_LINUX_H +#define _LIBNVME_LINUX_H + +#include <stddef.h> + +#include "ioctl.h" +#include "types.h" + +/** + * DOC: linux.h + * + * linux-specific utility functions + */ + +/** + * nvme_fw_download_seq() - Firmware download sequence + * @fd: File descriptor of nvme device + * @size: Total size of the firmware image to transfer + * @xfer: Maximum size to send with each partial transfer + * @offset: Starting offset to send with this firmware downlaod + * @buf: Address of buffer containing all or part of the firmware image. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_fw_download_seq(int fd, __u32 size, __u32 xfer, __u32 offset, + void *buf); + +/** + * enum nvme_telemetry_da - Telemetry Log Data Area + * @NVME_TELEMETRY_DA_1: Data Area 1 + * @NVME_TELEMETRY_DA_2: Data Area 2 + * @NVME_TELEMETRY_DA_3: Data Area 3 + * @NVME_TELEMETRY_DA_4: Data Area 4 + */ +enum nvme_telemetry_da { + NVME_TELEMETRY_DA_1 = 1, + NVME_TELEMETRY_DA_2 = 2, + NVME_TELEMETRY_DA_3 = 3, + NVME_TELEMETRY_DA_4 = 4, +}; + +/** + * nvme_get_ctrl_telemetry() - Get controller telemetry log + * @fd: File descriptor of nvme device + * @rae: Retain asynchronous events + * @log: On success, set to the value of the allocated and retrieved log. + * @da: Log page data area, valid values: &enum nvme_telemetry_da + * @size: Ptr to the telemetry log size, so it can be returned + * + * The total size allocated can be calculated as: + * (nvme_telemetry_log da size + 1) * NVME_LOG_TELEM_BLOCK_SIZE. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_ctrl_telemetry(int fd, bool rae, struct nvme_telemetry_log **log, + enum nvme_telemetry_da da, size_t *size); + +/** + * nvme_get_host_telemetry() - Get host telemetry log + * @fd: File descriptor of nvme device + * @log: On success, set to the value of the allocated and retrieved log. + * @da: Log page data area, valid values: &enum nvme_telemetry_da + * @size: Ptr to the telemetry log size, so it can be returned + * + * The total size allocated can be calculated as: + * (nvme_telemetry_log da size + 1) * NVME_LOG_TELEM_BLOCK_SIZE. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_host_telemetry(int fd, struct nvme_telemetry_log **log, + enum nvme_telemetry_da da, size_t *size); + +/** + * nvme_get_new_host_telemetry() - Get new host telemetry log + * @fd: File descriptor of nvme device + * @log: On success, set to the value of the allocated and retrieved log. + * @da: Log page data area, valid values: &enum nvme_telemetry_da + * @size: Ptr to the telemetry log size, so it can be returned + * + * The total size allocated can be calculated as: + * (nvme_telemetry_log da size + 1) * NVME_LOG_TELEM_BLOCK_SIZE. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_new_host_telemetry(int fd, struct nvme_telemetry_log **log, + enum nvme_telemetry_da da, size_t *size); + +/** + * nvme_get_log_page() - Get log page data + * @fd: File descriptor of nvme device + * @xfer_len: Max log transfer size per request to split the total. + * @args: &struct nvme_get_log_args argument structure + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_log_page(int fd, __u32 xfer_len, struct nvme_get_log_args *args); + +/** + * nvme_get_ana_log_len() - Retreive size of the current ANA log + * @fd: File descriptor of nvme device + * @analen: Pointer to where the length will be set on success + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_ana_log_len(int fd, size_t *analen); + +/** + * nvme_get_logical_block_size() - Retrieve block size + * @fd: File descriptor of nvme device + * @nsid: Namespace id + * @blksize: Pointer to where the block size will be set on success + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_logical_block_size(int fd, __u32 nsid, int *blksize); + +/** + * nvme_get_lba_status_log() - Retreive the LBA Status log page + * @fd: File descriptor of the nvme device + * @rae: Retain asynchronous events + * @log: On success, set to the value of the allocated and retreived log. + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_get_lba_status_log(int fd, bool rae, struct nvme_lba_status_log **log); + +/** + * nvme_namespace_attach_ctrls() - Attach namespace to controller(s) + * @fd: File descriptor of nvme device + * @nsid: Namespace ID to attach + * @num_ctrls: Number of controllers in ctrlist + * @ctrlist: List of controller IDs to perform the attach action + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_namespace_attach_ctrls(int fd, __u32 nsid, __u16 num_ctrls, __u16 *ctrlist); + +/** + * nvme_namespace_detach_ctrls() - Detach namespace from controller(s) + * @fd: File descriptor of nvme device + * @nsid: Namespace ID to detach + * @num_ctrls: Number of controllers in ctrlist + * @ctrlist: List of controller IDs to perform the detach action + * + * Return: The nvme command status if a response was received (see + * &enum nvme_status_field) or -1 with errno set otherwise. + */ +int nvme_namespace_detach_ctrls(int fd, __u32 nsid, __u16 num_ctrls, __u16 *ctrlist); + +/** + * nvme_open() - Open an nvme controller or namespace device + * @name: The basename of the device to open + * + * This will look for the handle in /dev/ and validate the name and filetype + * match linux conventions. + * + * Return: A file descriptor for the device on a successful open, or -1 with + * errno set otherwise. + */ +int nvme_open(const char *name); + +/** + * enum nvme_hmac_alg - HMAC algorithm + * @NVME_HMAC_ALG_NONE: No HMAC algorithm + * @NVME_HMAC_ALG_SHA2_256: SHA2-256 + * @NVME_HMAC_ALG_SHA2_384: SHA2-384 + * @NVME_HMAC_ALG_SHA2_512: SHA2-512 + */ +enum nvme_hmac_alg { + NVME_HMAC_ALG_NONE = 0, + NVME_HMAC_ALG_SHA2_256 = 1, + NVME_HMAC_ALG_SHA2_384 = 2, + NVME_HMAC_ALG_SHA2_512 = 3, +}; + +/** + * nvme_gen_dhchap_key() - DH-HMAC-CHAP key generation + * @hostnqn: Host NVMe Qualified Name + * @hmac: HMAC algorithm + * @key_len: Output key length + * @secret: Secret to used for digest + * @key: Generated DH-HMAC-CHAP key + * + * Return: If key generation was successful the function returns 0 or + * -1 with errno set otherwise. + */ +int nvme_gen_dhchap_key(char *hostnqn, enum nvme_hmac_alg hmac, + unsigned int key_len, unsigned char *secret, + unsigned char *key); + +#endif /* _LIBNVME_LINUX_H */ diff --git a/src/nvme/log.c b/src/nvme/log.c new file mode 100644 index 0000000..1bc44f2 --- /dev/null +++ b/src/nvme/log.c @@ -0,0 +1,99 @@ +/* + * Copyright (C) 2021 SUSE LLC + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License version + * 2 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. + * + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + * + * This file implements basic logging functionality. + */ + +#include <sys/types.h> +#include <stdio.h> +#include <stdlib.h> +#include <stdarg.h> +#include <stdbool.h> +#include <syslog.h> +#include <unistd.h> +#include <time.h> +#include <string.h> +#define LOG_FUNCNAME 1 +#include "private.h" +#include "log.h" +#include "cleanup.h" + +#ifndef LOG_CLOCK +#define LOG_CLOCK CLOCK_MONOTONIC +#endif + +void __attribute__((format(printf, 4, 5))) +__nvme_msg(nvme_root_t r, int lvl, + const char *func, const char *format, ...) +{ + FILE *fp = r ? r->fp : stderr; + va_list ap; + char pidbuf[16]; + char timebuf[32]; + static const char *const formats[] = { + "%s%s%s", + "%s%s%s: ", + "%s<%s>%s ", + "%s<%s> %s: ", + "[%s] %s%s ", + "[%s]%s %s: ", + "[%s] <%s>%s ", + "[%s] <%s> %s: ", + }; + char *header __cleanup__(cleanup_charp) = NULL; + char *message __cleanup__(cleanup_charp) = NULL; + int idx = 0; + + if (r && lvl > r->log_level) + return; + + if (r && r->log_timestamp) { + struct timespec now; + + clock_gettime(LOG_CLOCK, &now); + snprintf(timebuf, sizeof(timebuf), "%6ld.%06ld", + (long)now.tv_sec, now.tv_nsec / 1000); + idx |= 1 << 2; + } else + *timebuf = '\0'; + + if (r && r->log_pid) { + snprintf(pidbuf, sizeof(pidbuf), "%ld", (long)getpid()); + idx |= 1 << 1; + } else + *pidbuf = '\0'; + + if (func) + idx |= 1 << 0; + + if (asprintf(&header, formats[idx], + timebuf, pidbuf, func ? func : "") == -1) + header = NULL; + + va_start(ap, format); + if (vasprintf(&message, format, ap) == -1) + message = NULL; + va_end(ap); + + fprintf(fp, "%s%s", + header ? header : "<error>", + message ? message : "<error>"); +} + +void nvme_init_logging(nvme_root_t r, int lvl, bool log_pid, bool log_tstamp) +{ + r->log_level = lvl; + r->log_pid = log_pid; + r->log_timestamp = log_tstamp; +} diff --git a/src/nvme/log.h b/src/nvme/log.h new file mode 100644 index 0000000..1cf797a --- /dev/null +++ b/src/nvme/log.h @@ -0,0 +1,38 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/* + * Copyright (c) 2021 Martin Wilck, SUSE LLC + */ +#ifndef _LOG_H +#define _LOG_H + +#include <stdbool.h> +#include <syslog.h> + +/* for nvme_root_t */ +#include "tree.h" + +#ifndef MAX_LOGLEVEL +# define MAX_LOGLEVEL LOG_DEBUG +#endif +#ifndef DEFAULT_LOGLEVEL +# define DEFAULT_LOGLEVEL LOG_NOTICE +#endif + +/** + * DOC: log.h + * + * logging functions + */ + +/** + * nvme_init_logging() - Initialize logging + * @r: nvme_root_t context + * @lvl: Logging level to set + * @log_pid: Boolean to enable logging of the PID + * @log_tstamp: Boolean to enable logging of the timestamp + * + * Sets the default logging variables for the library. + */ +void nvme_init_logging(nvme_root_t r, int lvl, bool log_pid, bool log_tstamp); + +#endif /* _LOG_H */ diff --git a/src/nvme/private.h b/src/nvme/private.h new file mode 100644 index 0000000..bea1ae9 --- /dev/null +++ b/src/nvme/private.h @@ -0,0 +1,151 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/* + * This file is part of libnvme. + * Copyright (c) 2021 SUSE Software Solutions + * + * Authors: Hannes Reinecke <hare@suse.de> + */ + +#ifndef _LIBNVME_PRIVATE_H +#define _LIBNVME_PRIVATE_H + +#include <ccan/list/list.h> + +#include "fabrics.h" + +#include <uuid/uuid.h> + + +extern const char *nvme_ctrl_sysfs_dir; +extern const char *nvme_subsys_sysfs_dir; +extern const char *nvme_ns_sysfs_dir; + +struct nvme_path { + struct list_node entry; + struct list_node nentry; + + struct nvme_ctrl *c; + struct nvme_ns *n; + + char *name; + char *sysfs_dir; + char *ana_state; + int grpid; +}; + +struct nvme_ns { + struct list_node entry; + struct list_head paths; + + struct nvme_subsystem *s; + struct nvme_ctrl *c; + + int fd; + __u32 nsid; + char *name; + char *generic_name; + char *sysfs_dir; + + int lba_shift; + int lba_size; + int meta_size; + uint64_t lba_count; + uint64_t lba_util; + + uint8_t eui64[8]; + uint8_t nguid[16]; + uuid_t uuid; + enum nvme_csi csi; +}; + +struct nvme_ctrl { + struct list_node entry; + struct list_head paths; + struct list_head namespaces; + struct nvme_subsystem *s; + + int fd; + char *name; + char *sysfs_dir; + char *address; + char *firmware; + char *model; + char *state; + char *numa_node; + char *queue_count; + char *serial; + char *sqsize; + char *transport; + char *subsysnqn; + char *traddr; + char *trsvcid; + char *dhchap_key; + char *cntrltype; + char *dctype; + bool discovery_ctrl; + bool discovered; + bool persistent; + struct nvme_fabrics_config cfg; +}; + +struct nvme_subsystem { + struct list_node entry; + struct list_head ctrls; + struct list_head namespaces; + struct nvme_host *h; + + char *name; + char *sysfs_dir; + char *subsysnqn; + char *model; + char *serial; + char *firmware; + char *subsystype; +}; + +struct nvme_host { + struct list_node entry; + struct list_head subsystems; + struct nvme_root *r; + + char *hostnqn; + char *hostid; + char *dhchap_key; + char *hostsymname; +}; + +struct nvme_root { + char *config_file; + struct list_head hosts; + FILE *fp; + int log_level; + bool log_pid; + bool log_timestamp; + bool modified; +}; + +int nvme_set_attr(const char *dir, const char *attr, const char *value); + +int json_read_config(nvme_root_t r, const char *config_file); + +int json_update_config(nvme_root_t r, const char *config_file); + +int json_dump_tree(nvme_root_t r); + +#if (LOG_FUNCNAME == 1) +#define __nvme_log_func __func__ +#else +#define __nvme_log_func NULL +#endif + +void __attribute__((format(printf, 4, 5))) +__nvme_msg(nvme_root_t r, int lvl, const char *func, const char *format, ...); + +#define nvme_msg(r, lvl, format, ...) \ + do { \ + if ((lvl) <= MAX_LOGLEVEL) \ + __nvme_msg(r, lvl, __nvme_log_func, \ + format, ##__VA_ARGS__); \ + } while (0) + +#endif /* _LIBNVME_PRIVATE_H */ diff --git a/src/nvme/tree.c b/src/nvme/tree.c new file mode 100644 index 0000000..a2cfa6a --- /dev/null +++ b/src/nvme/tree.c @@ -0,0 +1,1909 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/* + * This file is part of libnvme. + * Copyright (c) 2020 Western Digital Corporation or its affiliates. + * + * Authors: Keith Busch <keith.busch@wdc.com> + * Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com> + */ +#include <dirent.h> +#include <errno.h> +#include <stdint.h> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <fcntl.h> +#include <libgen.h> +#include <unistd.h> + +#include <sys/types.h> +#include <sys/stat.h> +#include <arpa/inet.h> +#include <netdb.h> + +#include <ccan/endian/endian.h> +#include <ccan/list/list.h> + +#include "ioctl.h" +#include "linux.h" +#include "filters.h" +#include "tree.h" +#include "filters.h" +#include "util.h" +#include "fabrics.h" +#include "log.h" +#include "private.h" + +static struct nvme_host *default_host; + +static void __nvme_free_host(nvme_host_t h); +static void __nvme_free_ctrl(nvme_ctrl_t c); +static int nvme_subsystem_scan_namespace(nvme_root_t r, + struct nvme_subsystem *s, char *name, + nvme_scan_filter_t f, void *f_args); +static int nvme_init_subsystem(nvme_subsystem_t s, const char *name); +static int nvme_scan_subsystem(nvme_root_t r, const char *name, + nvme_scan_filter_t f, void *f_args); +static int nvme_ctrl_scan_namespace(nvme_root_t r, struct nvme_ctrl *c, + char *name); +static int nvme_ctrl_scan_path(nvme_root_t r, struct nvme_ctrl *c, char *name); + +static inline void nvme_free_dirents(struct dirent **d, int i) +{ + while (i-- > 0) + free(d[i]); + free(d); +} + +nvme_host_t nvme_default_host(nvme_root_t r) +{ + struct nvme_host *h; + char *hostnqn, *hostid; + + hostnqn = nvmf_hostnqn_from_file(); + if (!hostnqn) + hostnqn = nvmf_hostnqn_generate(); + hostid = nvmf_hostid_from_file(); + + h = nvme_lookup_host(r, hostnqn, hostid); + + nvme_host_set_hostsymname(h, NULL); + + default_host = h; + free(hostnqn); + if (hostid) + free(hostid); + return h; +} + +int nvme_scan_topology(struct nvme_root *r, nvme_scan_filter_t f, void *f_args) +{ + struct dirent **subsys, **ctrls; + int i, num_subsys, num_ctrls, ret; + + if (!r) + return 0; + + num_ctrls = nvme_scan_ctrls(&ctrls); + if (num_ctrls < 0) { + nvme_msg(r, LOG_DEBUG, "failed to scan ctrls: %s\n", + strerror(errno)); + return num_ctrls; + } + + for (i = 0; i < num_ctrls; i++) { + nvme_ctrl_t c = nvme_scan_ctrl(r, ctrls[i]->d_name); + if (!c) { + nvme_msg(r, LOG_DEBUG, "failed to scan ctrl %s: %s\n", + ctrls[i]->d_name, strerror(errno)); + continue; + } + if ((f) && !f(NULL, c, NULL, f_args)) { + nvme_msg(r, LOG_DEBUG, "filter out controller %s\n", + ctrls[i]->d_name); + nvme_free_ctrl(c); + } + } + + nvme_free_dirents(ctrls, i); + + num_subsys = nvme_scan_subsystems(&subsys); + if (num_subsys < 0) { + nvme_msg(r, LOG_DEBUG, "failed to scan subsystems: %s\n", + strerror(errno)); + return num_subsys; + } + + for (i = 0; i < num_subsys; i++) { + ret = nvme_scan_subsystem(r, subsys[i]->d_name, f, f_args); + if (ret < 0) { + nvme_msg(r, LOG_DEBUG, + "failed to scan subsystem %s: %s\n", + subsys[i]->d_name, strerror(errno)); + } + } + + nvme_free_dirents(subsys, i); + + return 0; +} + +nvme_root_t nvme_create_root(FILE *fp, int log_level) +{ + struct nvme_root *r = calloc(1, sizeof(*r)); + + if (!r) { + errno = ENOMEM; + return NULL; + } + r->log_level = log_level; + r->fp = stderr; + if (fp) + r->fp = fp; + list_head_init(&r->hosts); + return r; +} + +int nvme_read_config(nvme_root_t r, const char *config_file) +{ + int err = -1; + + if (!r || !config_file) { + errno = ENODEV; + return err; + } + + r->config_file = strdup(config_file); + if (!r->config_file) { + errno = ENOMEM; + return err; + } + err = json_read_config(r, config_file); + /* + * The json configuration file is optional, + * so ignore errors when opening the file. + */ + if (err < 0 && errno != EPROTO) + err = 0; + + return err; +} + +nvme_root_t nvme_scan(const char *config_file) +{ + nvme_root_t r = nvme_create_root(NULL, DEFAULT_LOGLEVEL); + + nvme_scan_topology(r, NULL, NULL); + nvme_read_config(r, config_file); + return r; +} + +int nvme_update_config(nvme_root_t r) +{ + if (!r->modified || !r->config_file) + return 0; + + return json_update_config(r, r->config_file); +} + +int nvme_dump_config(nvme_root_t r) +{ + return json_update_config(r, NULL); +} + +int nvme_dump_tree(nvme_root_t r) +{ + return json_dump_tree(r); +} + +nvme_host_t nvme_first_host(nvme_root_t r) +{ + return list_top(&r->hosts, struct nvme_host, entry); +} + +nvme_host_t nvme_next_host(nvme_root_t r, nvme_host_t h) +{ + return h ? list_next(&r->hosts, h, entry) : NULL; +} + +nvme_root_t nvme_host_get_root(nvme_host_t h) +{ + return h->r; +} + +const char *nvme_host_get_hostnqn(nvme_host_t h) +{ + return h->hostnqn; +} + +const char *nvme_host_get_hostid(nvme_host_t h) +{ + return h->hostid; +} + +const char *nvme_host_get_hostsymname(nvme_host_t h) +{ + return h->hostsymname; +} + +void nvme_host_set_hostsymname(nvme_host_t h, const char *hostsymname) +{ + if (h->hostsymname) { + free(h->hostsymname); + h->hostsymname = NULL; + } + if (hostsymname) + h->hostsymname = strdup(hostsymname); +} + +const char *nvme_host_get_dhchap_key(nvme_host_t h) +{ + return h->dhchap_key; +} + +void nvme_host_set_dhchap_key(nvme_host_t h, const char *key) +{ + if (h->dhchap_key) { + free(h->dhchap_key); + h->dhchap_key = NULL; + } + if (key) + h->dhchap_key = strdup(key); +} + +nvme_subsystem_t nvme_first_subsystem(nvme_host_t h) +{ + return list_top(&h->subsystems, struct nvme_subsystem, entry); +} + +nvme_subsystem_t nvme_next_subsystem(nvme_host_t h, nvme_subsystem_t s) +{ + return s ? list_next(&h->subsystems, s, entry) : NULL; +} + +void nvme_refresh_topology(nvme_root_t r) +{ + struct nvme_host *h, *_h; + + nvme_for_each_host_safe(r, h, _h) + __nvme_free_host(h); + nvme_scan_topology(r, NULL, NULL); +} + +void nvme_free_tree(nvme_root_t r) +{ + struct nvme_host *h, *_h; + + nvme_for_each_host_safe(r, h, _h) + __nvme_free_host(h); + if (r->config_file) + free(r->config_file); + free(r); +} + +const char *nvme_subsystem_get_nqn(nvme_subsystem_t s) +{ + return s->subsysnqn; +} + +const char *nvme_subsystem_get_sysfs_dir(nvme_subsystem_t s) +{ + return s->sysfs_dir; +} + +const char *nvme_subsystem_get_name(nvme_subsystem_t s) +{ + return s->name; +} + +const char *nvme_subsystem_get_type(nvme_subsystem_t s) +{ + return s->subsystype; +} + +nvme_ctrl_t nvme_subsystem_first_ctrl(nvme_subsystem_t s) +{ + return list_top(&s->ctrls, struct nvme_ctrl, entry); +} + +nvme_ctrl_t nvme_subsystem_next_ctrl(nvme_subsystem_t s, nvme_ctrl_t c) +{ + return c ? list_next(&s->ctrls, c, entry) : NULL; +} + +nvme_host_t nvme_subsystem_get_host(nvme_subsystem_t s) +{ + return s->h; +} + +nvme_ns_t nvme_subsystem_first_ns(nvme_subsystem_t s) +{ + return list_top(&s->namespaces, struct nvme_ns, entry); +} + +nvme_ns_t nvme_subsystem_next_ns(nvme_subsystem_t s, nvme_ns_t n) +{ + return n ? list_next(&s->namespaces, n, entry) : NULL; +} + +nvme_path_t nvme_namespace_first_path(nvme_ns_t ns) +{ + return list_top(&ns->paths, struct nvme_path, nentry); +} + +nvme_path_t nvme_namespace_next_path(nvme_ns_t ns, nvme_path_t p) +{ + return p ? list_next(&ns->paths, p, nentry) : NULL; +} + +static void __nvme_free_ns(struct nvme_ns *n) +{ + list_del_init(&n->entry); + close(n->fd); + free(n->generic_name); + free(n->name); + free(n->sysfs_dir); + free(n); +} + +/* Stub for SWIG */ +void nvme_free_ns(struct nvme_ns *n) +{ +} + +static void __nvme_free_subsystem(struct nvme_subsystem *s) +{ + struct nvme_ctrl *c, *_c; + struct nvme_ns *n, *_n; + + list_del_init(&s->entry); + nvme_subsystem_for_each_ctrl_safe(s, c, _c) + __nvme_free_ctrl(c); + + nvme_subsystem_for_each_ns_safe(s, n, _n) + __nvme_free_ns(n); + + if (s->name) + free(s->name); + free(s->sysfs_dir); + free(s->subsysnqn); + if (s->model) + free(s->model); + if (s->serial) + free(s->serial); + if (s->firmware) + free(s->firmware); + if (s->subsystype) + free(s->subsystype); + free(s); +} + +/* + * Stub for SWIG + */ +void nvme_free_subsystem(nvme_subsystem_t s) +{ +} + +struct nvme_subsystem *nvme_alloc_subsystem(struct nvme_host *h, + const char *name, + const char *subsysnqn) +{ + struct nvme_subsystem *s; + + s = calloc(1, sizeof(*s)); + if (!s) + return NULL; + + s->h = h; + s->subsysnqn = strdup(subsysnqn); + if (name) + nvme_init_subsystem(s, name); + list_head_init(&s->ctrls); + list_head_init(&s->namespaces); + list_node_init(&s->entry); + list_add(&h->subsystems, &s->entry); + h->r->modified = true; + return s; +} + +struct nvme_subsystem *nvme_lookup_subsystem(struct nvme_host *h, + const char *name, + const char *subsysnqn) +{ + struct nvme_subsystem *s; + + nvme_for_each_subsystem(h, s) { + if (strcmp(s->subsysnqn, subsysnqn)) + continue; + if (name && s->name && + strcmp(s->name, name)) + continue; + return s; + } + return nvme_alloc_subsystem(h, name, subsysnqn); +} + +static void __nvme_free_host(struct nvme_host *h) +{ + struct nvme_subsystem *s, *_s; + + list_del_init(&h->entry); + nvme_for_each_subsystem_safe(h, s, _s) + __nvme_free_subsystem(s); + free(h->hostnqn); + if (h->hostid) + free(h->hostid); + if (h->dhchap_key) + free(h->dhchap_key); + nvme_host_set_hostsymname(h, NULL); + h->r->modified = true; + free(h); +} + +/* Stub for SWIG */ +void nvme_free_host(struct nvme_host *h) +{ +} + +struct nvme_host *nvme_lookup_host(nvme_root_t r, const char *hostnqn, + const char *hostid) +{ + struct nvme_host *h; + + if (!hostnqn) + return NULL; + nvme_for_each_host(r, h) { + if (strcmp(h->hostnqn, hostnqn)) + continue; + if (hostid && (!h->hostid || + strcmp(h->hostid, hostid))) + continue; + return h; + } + h = calloc(1,sizeof(*h)); + if (!h) + return NULL; + h->hostnqn = strdup(hostnqn); + if (hostid) + h->hostid = strdup(hostid); + list_head_init(&h->subsystems); + list_node_init(&h->entry); + h->r = r; + list_add(&r->hosts, &h->entry); + r->modified = true; + + return h; +} + +static int nvme_subsystem_scan_namespaces(nvme_root_t r, nvme_subsystem_t s, + nvme_scan_filter_t f, void *f_args) +{ + struct dirent **namespaces; + int i, num_ns, ret; + + num_ns = nvme_scan_subsystem_namespaces(s, &namespaces); + if (num_ns < 0) { + nvme_msg(r, LOG_DEBUG, + "failed to scan namespaces for subsys %s: %s\n", + s->subsysnqn, strerror(errno)); + return num_ns; + } + + for (i = 0; i < num_ns; i++) { + ret = nvme_subsystem_scan_namespace(r, s, + namespaces[i]->d_name, f, f_args); + if (ret < 0) + nvme_msg(r, LOG_DEBUG, + "failed to scan namespace %s: %s\n", + namespaces[i]->d_name, strerror(errno)); + } + + nvme_free_dirents(namespaces, i); + return 0; +} + +static int nvme_init_subsystem(nvme_subsystem_t s, const char *name) +{ + char *path; + + if (asprintf(&path, "%s/%s", nvme_subsys_sysfs_dir, name) < 0) + return -1; + + s->model = nvme_get_attr(path, "model"); + if (!s->model) + s->model = strdup("undefined"); + s->serial = nvme_get_attr(path, "serial"); + s->firmware = nvme_get_attr(path, "firmware_rev"); + s->subsystype = nvme_get_attr(path, "subsystype"); + if (!s->subsystype) { + if (!strcmp(s->subsysnqn, NVME_DISC_SUBSYS_NAME)) + s->subsystype = strdup("discovery"); + else + s->subsystype = strdup("nvm"); + } + s->name = strdup(name); + s->sysfs_dir = (char *)path; + + return 0; +} + +static int nvme_scan_subsystem(struct nvme_root *r, const char *name, + nvme_scan_filter_t f, void *f_args) +{ + struct nvme_subsystem *s = NULL, *_s; + char *path, *subsysnqn; + nvme_host_t h = NULL; + int ret; + + nvme_msg(r, LOG_DEBUG, "scan subsystem %s\n", name); + ret = asprintf(&path, "%s/%s", nvme_subsys_sysfs_dir, name); + if (ret < 0) + return ret; + + subsysnqn = nvme_get_attr(path, "subsysnqn"); + free(path); + if (!subsysnqn) { + errno = ENODEV; + return -1; + } + nvme_for_each_host(r, h) { + nvme_for_each_subsystem(h, _s) { + /* + * We are always called after nvme_scan_ctrl(), + * so any subsystem we're interested at _must_ + * have a name. + */ + if (!_s->name) + continue; + if (strcmp(_s->name, name)) + continue; + s = _s; + } + } + if (!s) { + /* + * Subsystem with non-matching controller. odd. + * Create a subsystem with the default host + * and hope for the best. + */ + nvme_msg(r, LOG_DEBUG, "creating detached subsystem '%s'\n", + name); + h = nvme_default_host(r); + s = nvme_alloc_subsystem(h, name, subsysnqn); + if (!s) { + errno = ENOMEM; + } + } else if (strcmp(s->subsysnqn, subsysnqn)) { + nvme_msg(r, LOG_WARNING, "NQN mismatch for subsystem '%s'\n", + name); + s = NULL; + errno = EINVAL; + return -1; + } + free(subsysnqn); + if (!s) + return -1; + + if (f && !f(s, NULL, NULL, f_args)) { + nvme_msg(r, LOG_DEBUG, "filter out subsystem %s\n", name); + __nvme_free_subsystem(s); + return 0; + } + + nvme_subsystem_scan_namespaces(r, s, f, f_args); + + return 0; +} + +nvme_ctrl_t nvme_path_get_ctrl(nvme_path_t p) +{ + return p->c; +} + +nvme_ns_t nvme_path_get_ns(nvme_path_t p) +{ + return p->n; +} + +const char *nvme_path_get_sysfs_dir(nvme_path_t p) +{ + return p->sysfs_dir; +} + +const char *nvme_path_get_name(nvme_path_t p) +{ + return p->name; +} + +const char *nvme_path_get_ana_state(nvme_path_t p) +{ + return p->ana_state; +} + +void nvme_free_path(struct nvme_path *p) +{ + list_del_init(&p->entry); + list_del_init(&p->nentry); + free(p->name); + free(p->sysfs_dir); + free(p->ana_state); + free(p); +} + +static void nvme_subsystem_set_path_ns(nvme_subsystem_t s, nvme_path_t p) +{ + char n_name[32] = { }; + int i, c, nsid, ret; + nvme_ns_t n; + + ret = sscanf(nvme_path_get_name(p), "nvme%dc%dn%d", &i, &c, &nsid); + if (ret != 3) + return; + + sprintf(n_name, "nvme%dn%d", i, nsid); + nvme_subsystem_for_each_ns(s, n) { + if (!strcmp(n_name, nvme_ns_get_name(n))) { + list_add(&n->paths, &p->nentry); + p->n = n; + } + } +} + +static int nvme_ctrl_scan_path(nvme_root_t r, struct nvme_ctrl *c, char *name) +{ + struct nvme_path *p; + char *path, *grpid; + int ret; + + nvme_msg(r, LOG_DEBUG, "scan controller %s path %s\n", + c->name, name); + if (!c->s) { + errno = ENXIO; + return -1; + } + ret = asprintf(&path, "%s/%s", c->sysfs_dir, name); + if (ret < 0) { + errno = ENOMEM; + return -1; + } + + p = calloc(1, sizeof(*p)); + if (!p) { + errno = ENOMEM; + goto free_path; + } + + p->c = c; + p->name = strdup(name); + p->sysfs_dir = path; + p->ana_state = nvme_get_path_attr(p, "ana_state"); + if (!p->ana_state) + p->ana_state = strdup("optimized"); + + grpid = nvme_get_path_attr(p, "ana_grpid"); + if (grpid) { + sscanf(grpid, "%d", &p->grpid); + free(grpid); + } + + list_node_init(&p->nentry); + nvme_subsystem_set_path_ns(c->s, p); + list_node_init(&p->entry); + list_add(&c->paths, &p->entry); + return 0; + +free_path: + free(path); + return -1; +} + +int nvme_ctrl_get_fd(nvme_ctrl_t c) +{ + nvme_root_t r = c->s && c->s->h ? c->s->h->r : NULL; + + if (c->fd < 0) { + c->fd = nvme_open(c->name); + if (c->fd < 0) + nvme_msg(r, LOG_ERR, + "Failed to open ctrl %s, errno %d\n", + c->name, errno); + } + return c->fd; +} + +nvme_subsystem_t nvme_ctrl_get_subsystem(nvme_ctrl_t c) +{ + return c->s; +} + +const char *nvme_ctrl_get_name(nvme_ctrl_t c) +{ + return c->name; +} + +const char *nvme_ctrl_get_sysfs_dir(nvme_ctrl_t c) +{ + return c->sysfs_dir; +} + +const char *nvme_ctrl_get_subsysnqn(nvme_ctrl_t c) +{ + return c->s ? c->s->subsysnqn : c->subsysnqn; +} + +const char *nvme_ctrl_get_address(nvme_ctrl_t c) +{ + return c->address ? c->address : ""; +} + +const char *nvme_ctrl_get_firmware(nvme_ctrl_t c) +{ + return c->firmware; +} + +const char *nvme_ctrl_get_model(nvme_ctrl_t c) +{ + return c->model; +} + +const char *nvme_ctrl_get_state(nvme_ctrl_t c) +{ + char *state = c->state; + + c->state = nvme_get_ctrl_attr(c, "state"); + if (state) + free(state); + return c->state; +} + +const char *nvme_ctrl_get_numa_node(nvme_ctrl_t c) +{ + return c->numa_node; +} + +const char *nvme_ctrl_get_queue_count(nvme_ctrl_t c) +{ + return c->queue_count; +} + +const char *nvme_ctrl_get_serial(nvme_ctrl_t c) +{ + return c->serial; +} + +const char *nvme_ctrl_get_sqsize(nvme_ctrl_t c) +{ + return c->sqsize; +} + +const char *nvme_ctrl_get_transport(nvme_ctrl_t c) +{ + return c->transport; +} + +const char *nvme_ctrl_get_traddr(nvme_ctrl_t c) +{ + return c->traddr; +} + +const char *nvme_ctrl_get_trsvcid(nvme_ctrl_t c) +{ + return c->trsvcid; +} + +const char *nvme_ctrl_get_host_traddr(nvme_ctrl_t c) +{ + return c->cfg.host_traddr; +} + +const char *nvme_ctrl_get_host_iface(nvme_ctrl_t c) +{ + return c->cfg.host_iface; +} + +struct nvme_fabrics_config *nvme_ctrl_get_config(nvme_ctrl_t c) +{ + return &c->cfg; +} + +const char *nvme_ctrl_get_dhchap_key(nvme_ctrl_t c) +{ + return c->dhchap_key; +} + +void nvme_ctrl_set_dhchap_key(nvme_ctrl_t c, const char *key) +{ + if (c->dhchap_key) { + free(c->dhchap_key); + c->dhchap_key = NULL; + } + if (key) + c->dhchap_key = strdup(key); +} + +void nvme_ctrl_set_discovered(nvme_ctrl_t c, bool discovered) +{ + c->discovered = discovered; +} + +bool nvme_ctrl_is_discovered(nvme_ctrl_t c) +{ + return c->discovered; +} + +void nvme_ctrl_set_persistent(nvme_ctrl_t c, bool persistent) +{ + c->persistent = persistent; +} + +bool nvme_ctrl_is_persistent(nvme_ctrl_t c) +{ + return c->persistent; +} + +void nvme_ctrl_set_discovery_ctrl(nvme_ctrl_t c, bool discovery) +{ + c->discovery_ctrl = discovery; +} + +bool nvme_ctrl_is_discovery_ctrl(nvme_ctrl_t c) +{ + return c->discovery_ctrl; +} + +int nvme_ctrl_identify(nvme_ctrl_t c, struct nvme_id_ctrl *id) +{ + return nvme_identify_ctrl(nvme_ctrl_get_fd(c), id); +} + +nvme_ns_t nvme_ctrl_first_ns(nvme_ctrl_t c) +{ + return list_top(&c->namespaces, struct nvme_ns, entry); +} + +nvme_ns_t nvme_ctrl_next_ns(nvme_ctrl_t c, nvme_ns_t n) +{ + return n ? list_next(&c->namespaces, n, entry) : NULL; +} + +nvme_path_t nvme_ctrl_first_path(nvme_ctrl_t c) +{ + return list_top(&c->paths, struct nvme_path, entry); +} + +nvme_path_t nvme_ctrl_next_path(nvme_ctrl_t c, nvme_path_t p) +{ + return p ? list_next(&c->paths, p, entry) : NULL; +} + +#define FREE_CTRL_ATTR(a) \ + do { if (a) { free(a); (a) = NULL; } } while (0) +void nvme_deconfigure_ctrl(nvme_ctrl_t c) +{ + if (c->fd >= 0) { + close(c->fd); + c->fd = -1; + } + FREE_CTRL_ATTR(c->name); + FREE_CTRL_ATTR(c->sysfs_dir); + FREE_CTRL_ATTR(c->firmware); + FREE_CTRL_ATTR(c->model); + FREE_CTRL_ATTR(c->state); + FREE_CTRL_ATTR(c->numa_node); + FREE_CTRL_ATTR(c->queue_count); + FREE_CTRL_ATTR(c->serial); + FREE_CTRL_ATTR(c->sqsize); + FREE_CTRL_ATTR(c->address); + FREE_CTRL_ATTR(c->dctype); + FREE_CTRL_ATTR(c->cntrltype); +} + +int nvme_disconnect_ctrl(nvme_ctrl_t c) +{ + nvme_root_t r = c->s && c->s->h ? c->s->h->r : NULL; + int ret; + + ret = nvme_set_attr(nvme_ctrl_get_sysfs_dir(c), + "delete_controller", "1"); + if (ret < 0) { + nvme_msg(r, LOG_ERR, "%s: failed to disconnect, error %d\n", + c->name, errno); + return ret; + } + nvme_msg(r, LOG_INFO, "%s: disconnected\n", c->name); + nvme_deconfigure_ctrl(c); + return 0; +} + +void nvme_unlink_ctrl(nvme_ctrl_t c) +{ + list_del_init(&c->entry); + c->s = NULL; +} + +static void __nvme_free_ctrl(nvme_ctrl_t c) +{ + struct nvme_path *p, *_p; + struct nvme_ns *n, *_n; + + nvme_unlink_ctrl(c); + + nvme_ctrl_for_each_path_safe(c, p, _p) + nvme_free_path(p); + + nvme_ctrl_for_each_ns_safe(c, n, _n) + __nvme_free_ns(n); + + nvme_deconfigure_ctrl(c); + + FREE_CTRL_ATTR(c->transport); + FREE_CTRL_ATTR(c->subsysnqn); + FREE_CTRL_ATTR(c->traddr); + FREE_CTRL_ATTR(c->cfg.host_traddr); + FREE_CTRL_ATTR(c->cfg.host_iface); + FREE_CTRL_ATTR(c->trsvcid); + free(c); +} + +void nvme_free_ctrl(nvme_ctrl_t c) +{ + __nvme_free_ctrl(c); +} + +static bool traddr_is_hostname(const char *transport, const char *traddr) +{ + char addrstr[NVMF_TRADDR_SIZE]; + + if (!traddr || !transport) + return false; + if (strcmp(transport, "tcp") && + strcmp(transport, "rdma")) + return false; + if (inet_pton(AF_INET, traddr, addrstr) > 0 || + inet_pton(AF_INET6, traddr, addrstr) > 0) + return false; + return true; +} + +struct nvme_ctrl *nvme_create_ctrl(nvme_root_t r, + const char *subsysnqn, const char *transport, + const char *traddr, const char *host_traddr, + const char *host_iface, const char *trsvcid) +{ + struct nvme_ctrl *c; + + if (!transport) { + nvme_msg(r, LOG_ERR, "No transport specified\n"); + errno = EINVAL; + return NULL; + } + if (strncmp(transport, "loop", 4) && + strncmp(transport, "pcie", 4) && !traddr) { + nvme_msg(r, LOG_ERR, "No transport address for '%s'\n", + transport); + errno = EINVAL; + return NULL; + } + if (!subsysnqn) { + nvme_msg(r, LOG_ERR, "No subsystem NQN specified\n"); + errno = EINVAL; + return NULL; + } + c = calloc(1, sizeof(*c)); + if (!c) { + errno = ENOMEM; + return NULL; + } + c->fd = -1; + nvmf_default_config(&c->cfg); + list_head_init(&c->namespaces); + list_head_init(&c->paths); + list_node_init(&c->entry); + c->transport = strdup(transport); + c->subsysnqn = strdup(subsysnqn); + if (traddr) + c->traddr = strdup(traddr); + if (host_traddr) { + if (traddr_is_hostname(transport, host_traddr)) + c->cfg.host_traddr = hostname2traddr(r, host_traddr); + if (!c->cfg.host_traddr) + c->cfg.host_traddr = strdup(host_traddr); + } + if (host_iface) + c->cfg.host_iface = strdup(host_iface); + if (trsvcid) + c->trsvcid = strdup(trsvcid); + + return c; +} + +nvme_ctrl_t nvme_lookup_ctrl(nvme_subsystem_t s, const char *transport, + const char *traddr, const char *host_traddr, + const char *host_iface, const char *trsvcid, + nvme_ctrl_t p) +{ + nvme_root_t r; + struct nvme_ctrl *c; + + if (!s || !transport) + return NULL; + r = s->h ? s->h->r : NULL; + c = p ? nvme_subsystem_next_ctrl(s, p) : nvme_subsystem_first_ctrl(s); + for (; c != NULL; c = nvme_subsystem_next_ctrl(s, c)) { + if (strcmp(c->transport, transport)) + continue; + if (traddr && c->traddr && + strcasecmp(c->traddr, traddr)) + continue; + if (host_traddr && c->cfg.host_traddr && + strcmp(c->cfg.host_traddr, host_traddr)) + continue; + if (host_iface && c->cfg.host_iface && + strcmp(c->cfg.host_iface, host_iface)) + continue; + if (trsvcid && c->trsvcid && + strcmp(c->trsvcid, trsvcid)) + continue; + return c; + } + c = nvme_create_ctrl(r, s->subsysnqn, transport, traddr, + host_traddr, host_iface, trsvcid); + if (c) { + c->s = s; + list_add(&s->ctrls, &c->entry); + s->h->r->modified = true; + } + return c; +} + +static int nvme_ctrl_scan_paths(nvme_root_t r, struct nvme_ctrl *c) +{ + struct dirent **paths; + int i, ret; + + ret = nvme_scan_ctrl_namespace_paths(c, &paths); + if (ret < 0) + return ret; + + for (i = 0; i < ret; i++) + nvme_ctrl_scan_path(r, c, paths[i]->d_name); + + nvme_free_dirents(paths, i); + return 0; +} + +static int nvme_ctrl_scan_namespaces(nvme_root_t r, struct nvme_ctrl *c) +{ + struct dirent **namespaces; + int i, ret; + + ret = nvme_scan_ctrl_namespaces(c, &namespaces); + for (i = 0; i < ret; i++) + nvme_ctrl_scan_namespace(r, c, namespaces[i]->d_name); + + nvme_free_dirents(namespaces, i); + return 0; +} + +static char *nvme_ctrl_lookup_subsystem_name(nvme_root_t r, + const char *ctrl_name) +{ + struct dirent **subsys; + char *subsys_name = NULL; + int ret, i; + char path[PATH_MAX]; + + ret = nvme_scan_subsystems(&subsys); + if (ret < 0) + return NULL; + for (i = 0; i < ret; i++) { + struct stat st; + + sprintf(path, "%s/%s/%s", nvme_subsys_sysfs_dir, + subsys[i]->d_name, ctrl_name); + nvme_msg(r, LOG_DEBUG, "lookup subsystem %s\n", path); + if (stat(path, &st) < 0) + continue; + subsys_name = strdup(subsys[i]->d_name); + break; + } + nvme_free_dirents(subsys, ret); + return subsys_name; +} + +static int nvme_configure_ctrl(nvme_root_t r, nvme_ctrl_t c, const char *path, + const char *name) +{ + DIR *d; + + d = opendir(path); + if (!d) { + nvme_msg(r, LOG_ERR, "Failed to open ctrl dir %s, error %d\n", + path, errno); + errno = ENODEV; + return -1; + } + closedir(d); + + c->fd = -1; + c->name = strdup(name); + c->sysfs_dir = (char *)path; + c->firmware = nvme_get_ctrl_attr(c, "firmware_rev"); + c->model = nvme_get_ctrl_attr(c, "model"); + c->state = nvme_get_ctrl_attr(c, "state"); + c->numa_node = nvme_get_ctrl_attr(c, "numa_node"); + c->queue_count = nvme_get_ctrl_attr(c, "queue_count"); + c->serial = nvme_get_ctrl_attr(c, "serial"); + c->sqsize = nvme_get_ctrl_attr(c, "sqsize"); + c->dhchap_key = nvme_get_ctrl_attr(c, "dhchap_ctrl_secret"); + if (c->dhchap_key && !strcmp(c->dhchap_key, "none")) { + free(c->dhchap_key); + c->dhchap_key = NULL; + } + c->cntrltype = nvme_get_ctrl_attr(c, "cntrltype"); + c->dctype = nvme_get_ctrl_attr(c, "dctype"); + + errno = 0; /* cleanup after nvme_get_ctrl_attr() */ + return 0; +} + +int nvme_init_ctrl(nvme_host_t h, nvme_ctrl_t c, int instance) +{ + nvme_subsystem_t s; + char *subsys_name = NULL; + char *path, *name; + int ret; + + ret = asprintf(&name, "nvme%d", instance); + if (ret < 0) { + errno = ENOMEM; + return -1; + } + ret = asprintf(&path, "%s/nvme%d", nvme_ctrl_sysfs_dir, instance); + if (ret < 0) { + errno = ENOMEM; + goto out_free_name; + } + + ret = nvme_configure_ctrl(h->r, c, path, name); + if (ret < 0) { + free(path); + goto out_free_name; + } + + c->address = nvme_get_attr(path, "address"); + if (!c->address && strcmp(c->transport, "loop")) { + errno = ENVME_CONNECT_INVAL_TR; + ret = -1; + goto out_free_name; + } + + subsys_name = nvme_ctrl_lookup_subsystem_name(h->r, name); + if (!subsys_name) { + nvme_msg(h->r, LOG_ERR, + "Failed to lookup subsystem name for %s\n", + c->name); + errno = ENVME_CONNECT_LOOKUP_SUBSYS_NAME; + ret = -1; + goto out_free_name; + } + s = nvme_lookup_subsystem(h, subsys_name, c->subsysnqn); + if (!s) { + errno = ENVME_CONNECT_LOOKUP_SUBSYS; + ret = -1; + goto out_free_subsys; + } + if (s->subsystype && !strcmp(s->subsystype, "discovery")) + c->discovery_ctrl = true; + c->s = s; + list_add(&s->ctrls, &c->entry); +out_free_subsys: + free(subsys_name); + out_free_name: + free(name); + return ret; +} + +static nvme_ctrl_t nvme_ctrl_alloc(nvme_root_t r, nvme_subsystem_t s, + const char *path, const char *name) +{ + nvme_ctrl_t c, p; + char *addr = NULL, *address = NULL, *a, *e; + char *transport, *traddr = NULL, *trsvcid = NULL; + char *host_traddr = NULL, *host_iface = NULL; + int ret; + + transport = nvme_get_attr(path, "transport"); + if (!transport) { + errno = ENXIO; + return NULL; + } + /* Parse 'address' string into components */ + addr = nvme_get_attr(path, "address"); + if (!addr) { + char *rpath = NULL, *p = NULL, *_a = NULL; + + /* loop transport might not have an address */ + if (!strcmp(transport, "loop")) + goto skip_address; + + /* Older kernel don't support pcie transport addresses */ + if (strcmp(transport, "pcie")) { + free(transport); + errno = ENXIO; + return NULL; + } + /* Figure out the PCI address from the attribute path */ + rpath = realpath(path, NULL); + if (!rpath) { + free(transport); + errno = ENOMEM; + return NULL; + } + a = strtok_r(rpath, "/", &e); + while(a && strlen(a)) { + if (_a) + p = _a; + _a = a; + if (!strncmp(a, "nvme", 4)) + break; + a = strtok_r(NULL, "/", &e); + } + if (p) + addr = strdup(p); + free(rpath); + } else if (!strcmp(transport, "pcie")) { + /* The 'address' string is the transport address */ + traddr = addr; + } else { + address = strdup(addr); + a = strtok_r(address, ",", &e); + while (a && strlen(a)) { + if (!strncmp(a, "traddr=", 7)) + traddr = a + 7; + else if (!strncmp(a, "trsvcid=", 8)) + trsvcid = a + 8; + else if (!strncmp(a, "host_traddr=", 12)) + host_traddr = a + 12; + else if (!strncmp(a, "host_iface=", 11)) + host_iface = a + 11; + a = strtok_r(NULL, ",", &e); + } + } +skip_address: + p = NULL; + do { + c = nvme_lookup_ctrl(s, transport, traddr, + host_traddr, host_iface, trsvcid, p); + if (c) { + if (!c->name) + break; + if (!strcmp(c->name, name)) { + nvme_msg(r, LOG_DEBUG, + "found existing ctrl %s\n", c->name); + break; + } + nvme_msg(r, LOG_DEBUG, "skipping ctrl %s\n", c->name); + p = c; + } + } while (c); + if (!c) + c = p; + free(transport); + if (address) + free(address); + if (!c) { + if (!p) { + nvme_msg(r, LOG_ERR, "failed to lookup ctrl\n"); + errno = ENODEV; + } else + errno = ENOMEM; + return NULL; + } + c->address = addr; + if (s->subsystype && !strcmp(s->subsystype, "discovery")) + c->discovery_ctrl = true; + ret = nvme_configure_ctrl(r, c, path, name); + return (ret < 0) ? NULL : c; +} + +nvme_ctrl_t nvme_scan_ctrl(nvme_root_t r, const char *name) +{ + nvme_host_t h; + nvme_subsystem_t s; + nvme_ctrl_t c; + char *path; + char *hostnqn, *hostid, *subsysnqn, *subsysname; + int ret; + + nvme_msg(r, LOG_DEBUG, "scan controller %s\n", name); + ret = asprintf(&path, "%s/%s", nvme_ctrl_sysfs_dir, name); + if (ret < 0) { + errno = ENOMEM; + return NULL; + } + + hostnqn = nvme_get_attr(path, "hostnqn"); + hostid = nvme_get_attr(path, "hostid"); + h = nvme_lookup_host(r, hostnqn, hostid); + if (hostnqn) + free(hostnqn); + if (hostid) + free(hostid); + if (h) { + if (h->dhchap_key) + free(h->dhchap_key); + h->dhchap_key = nvme_get_attr(path, "dhchap_secret"); + if (h->dhchap_key && !strcmp(h->dhchap_key, "none")) { + free(h->dhchap_key); + h->dhchap_key = NULL; + } + } + if (!h) { + h = nvme_default_host(r); + if (!h) { + free(path); + errno = ENOMEM; + return NULL; + } + } + + subsysnqn = nvme_get_attr(path, "subsysnqn"); + if (!subsysnqn) { + free(path); + errno = ENXIO; + return NULL; + } + subsysname = nvme_ctrl_lookup_subsystem_name(r, name); + if (!subsysname) { + nvme_msg(r, LOG_ERR, + "failed to lookup subsystem for controller %s\n", + name); + free(path); + errno = ENXIO; + return NULL; + } + s = nvme_lookup_subsystem(h, subsysname, subsysnqn); + free(subsysnqn); + free(subsysname); + + if (!s) { + free(path); + errno = ENOMEM; + return NULL; + } + + c = nvme_ctrl_alloc(r, s, path, name); + if (!c) { + free(path); + return NULL; + } + + nvme_ctrl_scan_namespaces(r, c); + nvme_ctrl_scan_paths(r, c); + return c; +} + +void nvme_rescan_ctrl(struct nvme_ctrl *c) +{ + nvme_root_t r = c->s && c->s->h ? c->s->h->r : NULL; + if (!c->s) + return; + nvme_ctrl_scan_namespaces(r, c); + nvme_ctrl_scan_paths(r, c); + nvme_subsystem_scan_namespaces(r, c->s, NULL, NULL); +} + +static int nvme_bytes_to_lba(nvme_ns_t n, off_t offset, size_t count, + __u64 *lba, __u16 *nlb) +{ + int bs; + + bs = nvme_ns_get_lba_size(n); + if (!count || offset & bs || count & bs) { + errno = EINVAL; + return -1; + } + + *lba = offset >> n->lba_shift; + *nlb = (count >> n->lba_shift) - 1; + return 0; +} + +int nvme_ns_get_fd(nvme_ns_t n) +{ + return n->fd; +} + +nvme_subsystem_t nvme_ns_get_subsystem(nvme_ns_t n) +{ + return n->s; +} + +nvme_ctrl_t nvme_ns_get_ctrl(nvme_ns_t n) +{ + return n->c; +} + +int nvme_ns_get_nsid(nvme_ns_t n) +{ + return n->nsid; +} + +const char *nvme_ns_get_sysfs_dir(nvme_ns_t n) +{ + return n->sysfs_dir; +} + +const char *nvme_ns_get_name(nvme_ns_t n) +{ + return n->name; +} + +const char *nvme_ns_get_generic_name(nvme_ns_t n) +{ + return n->generic_name; +} + +const char *nvme_ns_get_model(nvme_ns_t n) +{ + return n->c ? n->c->model : n->s->model; +} + +const char *nvme_ns_get_serial(nvme_ns_t n) +{ + return n->c ? n->c->serial : n->s->serial; +} + +const char *nvme_ns_get_firmware(nvme_ns_t n) +{ + return n->c ? n->c->firmware : n->s->firmware; +} + +int nvme_ns_get_lba_size(nvme_ns_t n) +{ + return n->lba_size; +} + +int nvme_ns_get_meta_size(nvme_ns_t n) +{ + return n->meta_size; +} + +uint64_t nvme_ns_get_lba_count(nvme_ns_t n) +{ + return n->lba_count; +} + +uint64_t nvme_ns_get_lba_util(nvme_ns_t n) +{ + return n->lba_util; +} + +enum nvme_csi nvme_ns_get_csi(nvme_ns_t n) +{ + return n->csi; +} + +const uint8_t *nvme_ns_get_eui64(nvme_ns_t n) +{ + return n->eui64; +} + +const uint8_t *nvme_ns_get_nguid(nvme_ns_t n) +{ + return n->nguid; +} + +void nvme_ns_get_uuid(nvme_ns_t n, uuid_t out) +{ + uuid_copy(out, n->uuid); +} + +int nvme_ns_identify(nvme_ns_t n, struct nvme_id_ns *ns) +{ + return nvme_identify_ns(nvme_ns_get_fd(n), nvme_ns_get_nsid(n), ns); +} + +int nvme_ns_identify_descs(nvme_ns_t n, struct nvme_ns_id_desc *descs) +{ + return nvme_identify_ns_descs(nvme_ns_get_fd(n), nvme_ns_get_nsid(n), descs); +} + +int nvme_ns_verify(nvme_ns_t n, off_t offset, size_t count) +{ + struct nvme_io_args args = { + .args_size = sizeof(args), + .fd = nvme_ns_get_fd(n), + .nsid = nvme_ns_get_nsid(n), + .control = 0, + .dsm = 0, + .dspec = 0, + .reftag = 0, + .apptag = 0, + .appmask = 0, + .storage_tag = 0, + .data_len = 0, + .data = NULL, + .metadata_len = 0, + .metadata = NULL, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = NULL, + }; + + if (nvme_bytes_to_lba(n, offset, count, &args.slba, &args.nlb)) + return -1; + + return nvme_verify(&args); +} + +int nvme_ns_write_uncorrectable(nvme_ns_t n, off_t offset, size_t count) +{ + struct nvme_io_args args = { + .args_size = sizeof(args), + .fd = nvme_ns_get_fd(n), + .nsid = nvme_ns_get_nsid(n), + .control = 0, + .dsm = 0, + .dspec = 0, + .reftag = 0, + .apptag = 0, + .appmask = 0, + .storage_tag = 0, + .data_len = 0, + .data = NULL, + .metadata_len = 0, + .metadata = NULL, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = NULL, + }; + + if (nvme_bytes_to_lba(n, offset, count, &args.slba, &args.nlb)) + return -1; + + return nvme_write_uncorrectable(&args); +} + +int nvme_ns_write_zeros(nvme_ns_t n, off_t offset, size_t count) +{ + struct nvme_io_args args = { + .args_size = sizeof(args), + .fd = nvme_ns_get_fd(n), + .nsid = nvme_ns_get_nsid(n), + .control = 0, + .dsm = 0, + .dspec = 0, + .reftag = 0, + .apptag = 0, + .appmask = 0, + .storage_tag = 0, + .data_len = 0, + .data = NULL, + .metadata_len = 0, + .metadata = NULL, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = NULL, + }; + + if (nvme_bytes_to_lba(n, offset, count, &args.slba, &args.nlb)) + return -1; + + return nvme_write_zeros(&args); +} + +int nvme_ns_write(nvme_ns_t n, void *buf, off_t offset, size_t count) +{ + struct nvme_io_args args = { + .args_size = sizeof(args), + .fd = nvme_ns_get_fd(n), + .nsid = nvme_ns_get_nsid(n), + .control = 0, + .dsm = 0, + .dspec = 0, + .reftag = 0, + .apptag = 0, + .appmask = 0, + .storage_tag = 0, + .data_len = count, + .data = buf, + .metadata_len = 0, + .metadata = NULL, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = NULL, + }; + + if (nvme_bytes_to_lba(n, offset, count, &args.slba, &args.nlb)) + return -1; + + return nvme_write(&args); +} + +int nvme_ns_read(nvme_ns_t n, void *buf, off_t offset, size_t count) +{ + struct nvme_io_args args = { + .args_size = sizeof(args), + .fd = nvme_ns_get_fd(n), + .nsid = nvme_ns_get_nsid(n), + .control = 0, + .dsm = 0, + .dspec = 0, + .reftag = 0, + .apptag = 0, + .appmask = 0, + .storage_tag = 0, + .data_len = count, + .data = buf, + .metadata_len = 0, + .metadata = NULL, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = NULL, + }; + + if (nvme_bytes_to_lba(n, offset, count, &args.slba, &args.nlb)) + return -1; + + return nvme_read(&args); +} + +int nvme_ns_compare(nvme_ns_t n, void *buf, off_t offset, size_t count) +{ + struct nvme_io_args args = { + .args_size = sizeof(args), + .fd = nvme_ns_get_fd(n), + .nsid = nvme_ns_get_nsid(n), + .control = 0, + .dsm = 0, + .dspec = 0, + .reftag = 0, + .apptag = 0, + .appmask = 0, + .storage_tag = 0, + .data_len = count, + .data = buf, + .metadata_len = 0, + .metadata = NULL, + .timeout = NVME_DEFAULT_IOCTL_TIMEOUT, + .result = NULL, + }; + + if (nvme_bytes_to_lba(n, offset, count, &args.slba, &args.nlb)) + return -1; + + return nvme_compare(&args); +} + +int nvme_ns_flush(nvme_ns_t n) +{ + return nvme_flush(nvme_ns_get_fd(n), nvme_ns_get_nsid(n)); +} + +static void nvme_ns_parse_descriptors(struct nvme_ns *n, + struct nvme_ns_id_desc *descs) +{ + void *d = descs; + int i, len; + + for (i = 0; i < NVME_IDENTIFY_DATA_SIZE; i += len) { + struct nvme_ns_id_desc *desc = d + i; + + if (!desc->nidl) + break; + len = desc->nidl + sizeof(*desc); + + switch (desc->nidt) { + case NVME_NIDT_EUI64: + memcpy(n->eui64, desc->nid, sizeof(n->eui64)); + break; + case NVME_NIDT_NGUID: + memcpy(n->nguid, desc->nid, sizeof(n->nguid)); + break; + case NVME_NIDT_UUID: + memcpy(n->uuid, desc->nid, sizeof(n->uuid)); + break; + case NVME_NIDT_CSI: + memcpy(&n->csi, desc->nid, sizeof(n->csi)); + break; + } + } +} + +static int nvme_ns_init(struct nvme_ns *n) +{ + struct nvme_id_ns ns = { }; + uint8_t buffer[NVME_IDENTIFY_DATA_SIZE] = { }; + struct nvme_ns_id_desc *descs = (void *)buffer; + uint8_t flbas; + int ret; + + ret = nvme_ns_identify(n, &ns); + if (ret) + return ret; + + nvme_id_ns_flbas_to_lbaf_inuse(ns.flbas, &flbas); + n->lba_shift = ns.lbaf[flbas].ds; + n->lba_size = 1 << n->lba_shift; + n->lba_count = le64_to_cpu(ns.nsze); + n->lba_util = le64_to_cpu(ns.nuse); + n->meta_size = le16_to_cpu(ns.lbaf[flbas].ms); + + if (!nvme_ns_identify_descs(n, descs)) + nvme_ns_parse_descriptors(n, descs); + + return 0; +} + +static void nvme_ns_set_generic_name(struct nvme_ns *n, const char *name) +{ + char generic_name[PATH_MAX]; + int instance, head_instance; + int ret; + + ret = sscanf(name, "nvme%dn%d", &instance, &head_instance); + if (ret != 2) + return; + + sprintf(generic_name, "ng%dn%d", instance, head_instance); + n->generic_name = strdup(generic_name); +} + +static nvme_ns_t nvme_ns_open(const char *name) +{ + struct nvme_ns *n; + + n = calloc(1, sizeof(*n)); + if (!n) { + errno = ENOMEM; + return NULL; + } + + n->name = strdup(name); + n->fd = nvme_open(n->name); + if (n->fd < 0) + goto free_ns; + + nvme_ns_set_generic_name(n, name); + + if (nvme_get_nsid(n->fd, &n->nsid) < 0) + goto close_fd; + + if (nvme_ns_init(n) != 0) + goto close_fd; + + list_head_init(&n->paths); + list_node_init(&n->entry); + + return n; + +close_fd: + close(n->fd); +free_ns: + free(n->name); + free(n); + return NULL; +} + +static struct nvme_ns *__nvme_scan_namespace(const char *sysfs_dir, const char *name) +{ + struct nvme_ns *n; + char *path; + int ret; + + ret = asprintf(&path, "%s/%s", sysfs_dir, name); + if (ret < 0) { + errno = ENOMEM; + return NULL; + } + + n = nvme_ns_open(name); + if (!n) + goto free_path; + + n->sysfs_dir = path; + return n; + +free_path: + free(path); + return NULL; +} + +nvme_ns_t nvme_scan_namespace(const char *name) +{ + return __nvme_scan_namespace(nvme_ns_sysfs_dir, name); +} + +static int nvme_ctrl_scan_namespace(nvme_root_t r, struct nvme_ctrl *c, + char *name) +{ + struct nvme_ns *n; + + nvme_msg(r, LOG_DEBUG, "scan controller %s namespace %s\n", + c->name, name); + if (!c->s) { + nvme_msg(r, LOG_DEBUG, "no subsystem for %s\n", name); + errno = EINVAL; + return -1; + } + n = __nvme_scan_namespace(c->sysfs_dir, name); + if (!n) { + nvme_msg(r, LOG_DEBUG, "failed to scan namespace %s\n", name); + return -1; + } + + n->s = c->s; + n->c = c; + list_add(&c->namespaces, &n->entry); + return 0; +} + +static void nvme_subsystem_set_ns_path(nvme_subsystem_t s, nvme_ns_t n) +{ + nvme_ctrl_t c; + nvme_path_t p; + int ns_ctrl, ns_nsid, ret; + + ret = sscanf(nvme_ns_get_name(n), "nvme%dn%d", &ns_ctrl, &ns_nsid); + if (ret != 2) + return; + + nvme_subsystem_for_each_ctrl(s, c) { + nvme_ctrl_for_each_path(c, p) { + int p_subsys, p_ctrl, p_nsid; + + ret = sscanf(nvme_path_get_name(p), "nvme%dc%dn%d", + &p_subsys, &p_ctrl, &p_nsid); + if (ret != 3) + continue; + if (ns_ctrl == p_subsys && ns_nsid == p_nsid) { + list_add(&n->paths, &p->nentry); + p->n = n; + } + } + } +} + +static int nvme_subsystem_scan_namespace(nvme_root_t r, nvme_subsystem_t s, + char *name, nvme_scan_filter_t f, void *f_args) +{ + struct nvme_ns *n; + + nvme_msg(r, LOG_DEBUG, "scan subsystem %s namespace %s\n", + s->name, name); + n = __nvme_scan_namespace(s->sysfs_dir, name); + if (!n) { + nvme_msg(r, LOG_DEBUG, "failed to scan namespace %s\n", name); + return -1; + } + if (f && !f(NULL, NULL, n, f_args)) { + nvme_msg(r, LOG_DEBUG, "filter out namespace %s\n", name); + __nvme_free_ns(n); + return 0; + } + n->s = s; + list_add(&s->namespaces, &n->entry); + nvme_subsystem_set_ns_path(s, n); + return 0; +} + +struct nvme_ns *nvme_subsystem_lookup_namespace(struct nvme_subsystem *s, + __u32 nsid) +{ + nvme_root_t r = s->h ? s->h->r : NULL; + struct nvme_ns *n; + char *name; + int ret; + + ret = asprintf(&name, "%sn%u", s->name, nsid); + if (ret < 0) + return NULL; + n = __nvme_scan_namespace(s->sysfs_dir, name); + free(name); + if (!n) { + nvme_msg(r, LOG_DEBUG, "failed to scan namespace %d\n", nsid); + return NULL; + } + + n->s = s; + list_add(&s->namespaces, &n->entry); + return n; +} diff --git a/src/nvme/tree.h b/src/nvme/tree.h new file mode 100644 index 0000000..9f7a621 --- /dev/null +++ b/src/nvme/tree.h @@ -0,0 +1,1231 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/* + * This file is part of libnvme. + * Copyright (c) 2020 Western Digital Corporation or its affiliates. + * + * Authors: Keith Busch <keith.busch@wdc.com> + * Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com> + */ + +#ifndef _LIBNVME_TREE_H +#define _LIBNVME_TREE_H + +#include <stdio.h> +#include <stdbool.h> +#include <stddef.h> + +#include <sys/types.h> +#include <uuid/uuid.h> + +#include "ioctl.h" +#include "util.h" + +/** + * DOC: tree.h + * + * libnvme tree object interface + */ + +typedef struct nvme_ns *nvme_ns_t; +typedef struct nvme_path *nvme_path_t; +typedef struct nvme_ctrl *nvme_ctrl_t; +typedef struct nvme_subsystem *nvme_subsystem_t; +typedef struct nvme_host *nvme_host_t; +typedef struct nvme_root *nvme_root_t; + +typedef bool (*nvme_scan_filter_t)(nvme_subsystem_t, nvme_ctrl_t, + nvme_ns_t, void *); + +/** + * nvme_create_root() - Initialize root object + * @fp: File descriptor for logging messages + * @log_level: Logging level to use + * + * Return: Initialized &nvme_root_t object + */ +nvme_root_t nvme_create_root(FILE *fp, int log_level); + +/** + * nvme_free_tree() - Free root object + * @r: &nvme_root_t object + * + * Free an &nvme_root_t object and all attached objects + */ +void nvme_free_tree(nvme_root_t r); + +/** + * nvme_first_host() - Start host iterator + * @r: &nvme_root_t object + * + * Return: First &nvme_host_t object in an iterator + */ +nvme_host_t nvme_first_host(nvme_root_t r); + +/** + * nvme_next_host() - Next host iterator + * @r: &nvme_root_t object + * @h: Previous &nvme_host_t iterator + * + * Return: Next &nvme_host_t object in an iterator + */ +nvme_host_t nvme_next_host(nvme_root_t r, nvme_host_t h); + +/** + * nvme_host_get_root() - Returns nvme_root_t object + * @h: &nvme_host_t object + * + * Return: &nvme_root_t object from @h + */ +nvme_root_t nvme_host_get_root(nvme_host_t h); + +/** + * nvme_lookup_host() - Lookup nvme_host_t object + * @r: &nvme_root_t object + * @hostnqn: Host NQN + * @hostid: Host ID + * + * Lookup a nvme_host_t object based on @hostnqn and @hostid + * or create one if not found. + * + * Return: &nvme_host_t object + */ +nvme_host_t nvme_lookup_host(nvme_root_t r, const char *hostnqn, + const char *hostid); + +/** + * nvme_host_get_dhchap_key() - Return host key + * @h: Host for which the key should be returned + * + * Return: DH-HMAC-CHAP host key or NULL if not set + */ +const char *nvme_host_get_dhchap_key(nvme_host_t h); + +/** + * nvme_host_set_dhchap_key() - set host key + * @h: Host for which the key should be set + * @key: DH-HMAC-CHAP Key to set or NULL to clear existing key + */ +void nvme_host_set_dhchap_key(nvme_host_t h, const char *key); + +/** + * nvme_default_host() - Initializes the default host + * @r: &nvme_root_t object + * + * Initializes the default host object based on the values in + * /etc/nvme/hostnqn and /etc/nvme/hostid and attaches it to @r. + * + * Return: &nvme_host_t object + */ +nvme_host_t nvme_default_host(nvme_root_t r); + +/** + * nvme_first_subsystem() - Start subsystem iterator + * @h: &nvme_host_t object + * + * Return: first &nvme_subsystem_t object in an iterator + */ +nvme_subsystem_t nvme_first_subsystem(nvme_host_t h); + +/** + * nvme_next_subsystem() - Next subsystem iterator + * @h: &nvme_host_t object + * @s: Previous &nvme_subsystem_t iterator + * + * Return: next &nvme_subsystem_t object in an iterator + */ +nvme_subsystem_t nvme_next_subsystem(nvme_host_t h, nvme_subsystem_t s); + +/** + * nvme_lookup_subsystem() - Lookup nvme_subsystem_t object + * @h: &nvme_host_t object + * @name: Name of the subsystem (may be NULL) + * @subsysnqn: Subsystem NQN + * + * Lookup a &nvme_subsystem_t object in @h base on @name (if present) + * and @subsystemnqn or create one if not found. + * + * Return: nvme_subsystme_t object + */ +nvme_subsystem_t nvme_lookup_subsystem(struct nvme_host *h, + const char *name, + const char *subsysnqn); + +/** + * nvme_free_subsystem() - Free a subsystem + * @s: subsystem + * + * Frees @s and all related objects. + */ +void nvme_free_subsystem(struct nvme_subsystem *s); + +/** + * nvme_subsystem_get_host() - Returns nvme_host_t object + * @s: subsystem + * + * Return: &nvme_host_t object from @s + */ +nvme_host_t nvme_subsystem_get_host(nvme_subsystem_t s); + +/** + * nvme_ctrl_first_ns() - Start namespace iterator + * @c: Controller instance + * + * Return: First &nvme_ns_t object of an @c iterator + */ +nvme_ns_t nvme_ctrl_first_ns(nvme_ctrl_t c); + +/** + * nvme_ctrl_next_ns() - Next namespace iterator + * @c: Controller instance + * @n: Previous nvme_ns_t iterator + * + * Return: Next nvme_ns_t object of an @c iterator + */ +nvme_ns_t nvme_ctrl_next_ns(nvme_ctrl_t c, nvme_ns_t n); + +/** + * nvme_ctrl_first_path() - Start path iterator + * @c: Controller instance + * + * Return: First &nvme_path_t object of an @c iterator + */ +nvme_path_t nvme_ctrl_first_path(nvme_ctrl_t c); + +/** + * nvme_ctrl_next_path() - Next path iterator + * @c: Controller instance + * @p: Previous &nvme_path_t object of an @c iterator + * + * Return: Next &nvme_path_t object of an @c iterator + */ +nvme_path_t nvme_ctrl_next_path(nvme_ctrl_t c, nvme_path_t p); + +/** + * nvme_subsystem_first_ctrl() - First ctrl iterator + * @s: &nvme_subsystem_t object + * + * Return: First controller of an @s iterator + */ +nvme_ctrl_t nvme_subsystem_first_ctrl(nvme_subsystem_t s); + +/** + * nvme_subsystem_next_ctrl() - Next ctrl iterator + * @s: &nvme_subsystem_t object + * @c: Previous controller instance of an @s iterator + * + * Return: Next controller of an @s iterator + */ +nvme_ctrl_t nvme_subsystem_next_ctrl(nvme_subsystem_t s, nvme_ctrl_t c); + +/** + * nvme_namespace_first_path() - Start path iterator + * @ns: Namespace instance + * + * Return: First &nvme_path_t object of an @ns iterator + */ +nvme_path_t nvme_namespace_first_path(nvme_ns_t ns); + +/** + * nvme_namespace_next_path() - Next path iterator + * @ns: Namespace instance + * @p: Previous &nvme_path_t object of an @ns iterator + * + * Return: Next &nvme_path_t object of an @ns iterator + */ +nvme_path_t nvme_namespace_next_path(nvme_ns_t c, nvme_path_t p); + +/** + * nvme_lookup_ctrl() - Lookup nvme_ctrl_t object + * @s: &nvme_subsystem_t object + * @transport: Transport name + * @traddr: Transport address + * @host_traddr: Host transport address + * @host_iface: Host interface name + * @trsvcid: Transport service identifier + * @p: Previous controller instance + * + * Lookup a controller in @s based on @transport, @traddr, + * @host_traddr, @host_iface, and @trsvcid. @transport must be specified, + * other fields may be required depending on the transport. A new + * object is created if none is found. If @p is specified the lookup + * will start at @p instead of the first controller. + * + * Return: Controller instance + */ +nvme_ctrl_t nvme_lookup_ctrl(nvme_subsystem_t s, const char *transport, + const char *traddr, const char *host_traddr, + const char *host_iface, const char *trsvcid, + nvme_ctrl_t p); + + +/** + * nvme_create_ctrl() - Allocate an unconnected NVMe controller + * @r: NVMe root element + * @subsysnqn: Subsystem NQN + * @transport: Transport type + * @traddr: Transport address + * @host_traddr: Host transport address + * @host_iface: Host interface name + * @trsvcid: Transport service ID + * + * Creates an unconnected controller to be used for nvme_add_ctrl(). + * + * Return: Controller instance + */ +nvme_ctrl_t nvme_create_ctrl(nvme_root_t r, + const char *subsysnqn, const char *transport, + const char *traddr, const char *host_traddr, + const char *host_iface, const char *trsvcid); + + +/** + * nvme_subsystem_first_ns() - Start namespace iterator + * @s: &nvme_subsystem_t object + * + * Return: First &nvme_ns_t object of an @s iterator + */ +nvme_ns_t nvme_subsystem_first_ns(nvme_subsystem_t s); + +/** + * nvme_subsystem_next_ns() - Next namespace iterator + * @s: &nvme_subsystem_t object + * @n: Previous &nvme_ns_t iterator + * + * Return: Next &nvme_ns_t object of an @s iterator + */ +nvme_ns_t nvme_subsystem_next_ns(nvme_subsystem_t s, nvme_ns_t n); + +/** + * nvme_for_each_host_safe() - Traverse host list + * @r: &nvme_root_t object + * @h: &nvme_host_t object + * @_h: Temporary &nvme_host_t object + */ +#define nvme_for_each_host_safe(r, h, _h) \ + for (h = nvme_first_host(r), \ + _h = nvme_next_host(r, h); \ + h != NULL; \ + h = _h, _h = nvme_next_host(r, h)) + +/** + * nvme_for_each_host() - Traverse host list + * @r: &nvme_root_t object + * @h: &nvme_host_t object + */ +#define nvme_for_each_host(r, h) \ + for (h = nvme_first_host(r); h != NULL; \ + h = nvme_next_host(r, h)) + +/** + * nvme_for_each_subsystem_safe() - Traverse subsystems + * @h: &nvme_host_t object + * @s: &nvme_subsystem_t object + * @_s: Temporary &nvme_subsystem_t object + */ +#define nvme_for_each_subsystem_safe(h, s, _s) \ + for (s = nvme_first_subsystem(h), \ + _s = nvme_next_subsystem(h, s); \ + s != NULL; \ + s = _s, _s = nvme_next_subsystem(h, s)) + +/** + * nvme_for_each_subsystem() - Traverse subsystems + * @h: &nvme_host_t object + * @s: &nvme_subsystem_t object + */ +#define nvme_for_each_subsystem(h, s) \ + for (s = nvme_first_subsystem(h); s != NULL; \ + s = nvme_next_subsystem(h, s)) + +/** + * nvme_subsystem_for_each_ctrl_safe() - Traverse controllers + * @s: &nvme_subsystem_t object + * @c: Controller instance + * @_c: A &nvme_ctrl_t_node to use as temporary storage + */ +#define nvme_subsystem_for_each_ctrl_safe(s, c, _c) \ + for (c = nvme_subsystem_first_ctrl(s), \ + _c = nvme_subsystem_next_ctrl(s, c); \ + c != NULL; \ + c = _c, _c = nvme_subsystem_next_ctrl(s, c)) + +/** + * nvme_subsystem_for_each_ctrl() - Traverse controllers + * @s: &nvme_subsystem_t object + * @c: Controller instance + */ +#define nvme_subsystem_for_each_ctrl(s, c) \ + for (c = nvme_subsystem_first_ctrl(s); c != NULL; \ + c = nvme_subsystem_next_ctrl(s, c)) + +/** + * nvme_ctrl_for_each_ns_safe() - Traverse namespaces + * @c: Controller instance + * @n: &nvme_ns_t object + * @_n: A &nvme_ns_t_node to use as temporary storage + */ +#define nvme_ctrl_for_each_ns_safe(c, n, _n) \ + for (n = nvme_ctrl_first_ns(c), \ + _n = nvme_ctrl_next_ns(c, n); \ + n != NULL; \ + n = _n, _n = nvme_ctrl_next_ns(c, n)) + +/** + * nvme_ctrl_for_each_ns() - Traverse namespaces + * @c: Controller instance + * @n: &nvme_ns_t object + */ +#define nvme_ctrl_for_each_ns(c, n) \ + for (n = nvme_ctrl_first_ns(c); n != NULL; \ + n = nvme_ctrl_next_ns(c, n)) + +/** + * nvme_ctrl_for_each_path_safe() - Traverse paths + * @c: Controller instance + * @p: &nvme_path_t object + * @_p: A &nvme_path_t_node to use as temporary storage + */ +#define nvme_ctrl_for_each_path_safe(c, p, _p) \ + for (p = nvme_ctrl_first_path(c), \ + _p = nvme_ctrl_next_path(c, p); \ + p != NULL; \ + p = _p, _p = nvme_ctrl_next_path(c, p)) + +/** + * nvme_ctrl_for_each_path() - Traverse paths + * @c: Controller instance + * @p: &nvme_path_t object + */ +#define nvme_ctrl_for_each_path(c, p) \ + for (p = nvme_ctrl_first_path(c); p != NULL; \ + p = nvme_ctrl_next_path(c, p)) + +/** + * nvme_subsystem_for_each_ns_safe() - Traverse namespaces + * @s: &nvme_subsystem_t object + * @n: &nvme_ns_t object + * @_n: A &nvme_ns_t_node to use as temporary storage + */ +#define nvme_subsystem_for_each_ns_safe(s, n, _n) \ + for (n = nvme_subsystem_first_ns(s), \ + _n = nvme_subsystem_next_ns(s, n); \ + n != NULL; \ + n = _n, _n = nvme_subsystem_next_ns(s, n)) + +/** + * nvme_subsystem_for_each_ns() - Traverse namespaces + * @s: &nvme_subsystem_t object + * @n: &nvme_ns_t object + */ +#define nvme_subsystem_for_each_ns(s, n) \ + for (n = nvme_subsystem_first_ns(s); n != NULL; \ + n = nvme_subsystem_next_ns(s, n)) + +/** + * nvme_namespace_for_each_path_safe() - Traverse paths + * @ns: Namespace instance + * @p: &nvme_path_t object + * @_p: A &nvme_path_t_node to use as temporary storage + */ +#define nvme_namespace_for_each_path_safe(n, p, _p) \ + for (p = nvme_namespace_first_path(n), \ + _p = nvme_namespace_next_path(n, p); \ + p != NULL; \ + p = _p, _p = nvme_namespace_next_path(n, p)) + +/** + * nvme_namespace_for_each_path() - Traverse paths + * @ns: Namespace instance + * @p: &nvme_path_t object + */ +#define nvme_namespace_for_each_path(c, p) \ + for (p = nvme_namespace_first_path(c); p != NULL; \ + p = nvme_namespace_next_path(c, p)) + +/** + * nvme_ns_get_fd() - Get associated filedescriptor + * @n: Namespace instance + * + * Return: File descriptor associated with @n or -1 + */ +int nvme_ns_get_fd(nvme_ns_t n); + +/** + * nvme_ns_get_nsid() - NSID of a namespace + * @n: Namespace instance + * + * Return: NSID of @n + */ +int nvme_ns_get_nsid(nvme_ns_t n); + +/** + * nvme_ns_get_lba_size() - LBA size of a namespace + * @n: Namespace instance + * + * Return: LBA size of @n + */ +int nvme_ns_get_lba_size(nvme_ns_t n); + +/** + * nvme_ns_get_meta_size() - Metadata size of a namespace + * @n: Namespace instance + * + * Return: Metadata size of @n + */ +int nvme_ns_get_meta_size(nvme_ns_t n); + +/** + * nvme_ns_get_lba_count() - LBA count of a namespace + * @n: Namespace instance + * + * Return: LBA count of @n + */ +uint64_t nvme_ns_get_lba_count(nvme_ns_t n); + +/** + * nvme_ns_get_lba_util() - LBA utilisation of a namespace + * @n: Namespace instance + * + * Return: LBA utilisation of @n + */ +uint64_t nvme_ns_get_lba_util(nvme_ns_t n); + +/** + * nvme_ns_get_csi() - Command set identifier of a namespace + * @n: Namespace instance + * + * Return: The namespace's command set identifier in use + */ +enum nvme_csi nvme_ns_get_csi(nvme_ns_t n); + +/** + * nvme_ns_get_eui64() - 64-bit eui of a namespace + * @n: Namespace instance + * + * Return: A pointer to the 64-bit eui + */ +const uint8_t *nvme_ns_get_eui64(nvme_ns_t n); + +/** + * nvme_ns_get_nguid() - 128-bit nguid of a namespace + * @n: Namespace instance + * + * Return: A pointer to the 128-bit nguid + */ +const uint8_t *nvme_ns_get_nguid(nvme_ns_t n); + +/** + * nvme_ns_get_uuid() - UUID of a namespace + * @n: Namespace instance + * @out: buffer for the UUID + * + * Copies the namespace's uuid into @out + */ +void nvme_ns_get_uuid(nvme_ns_t n, uuid_t out); + +/** + * nvme_ns_get_sysfs_dir() - sysfs directory of a namespace + * @n: Namespace instance + * + * Return: sysfs directory name of @n + */ +const char *nvme_ns_get_sysfs_dir(nvme_ns_t n); + +/** + * nvme_ns_get_name() - sysfs name of a namespace + * @n: Namespace instance + * + * Return: sysfs name of @n + */ +const char *nvme_ns_get_name(nvme_ns_t n); + +/** + * nvme_ns_get_generic_name() - Returns name of generic namespace chardev. + * @n: Namespace instance + * + * Return: Name of generic namespace chardev + */ +const char *nvme_ns_get_generic_name(nvme_ns_t n); + +/** + * nvme_ns_get_firmware() - Firmware string of a namespace + * @n: Namespace instance + * + * Return: Firmware string of @n + */ +const char *nvme_ns_get_firmware(nvme_ns_t n); + +/** + * nvme_ns_get_serial() - Serial number of a namespace + * @n: Namespace instance + * + * Return: Serial number string of @n + */ +const char *nvme_ns_get_serial(nvme_ns_t n); + +/** + * nvme_ns_get_model() - Model of a namespace + * @n: Namespace instance + * + * Return: Model string of @n + */ +const char *nvme_ns_get_model(nvme_ns_t n); + +/** + * nvme_ns_get_subsystem() - &nvme_subsystem_t of a namespace + * @n: Namespace instance + * + * Return: nvme_subsystem_t object of @n + */ +nvme_subsystem_t nvme_ns_get_subsystem(nvme_ns_t n); + +/** + * nvme_ns_get_ctrl() - &nvme_ctrl_t of a namespace + * @n: Namespace instance + * + * nvme_ctrl_t object may be NULL for a multipathed namespace + * + * Return: nvme_ctrl_t object of @n if present + */ +nvme_ctrl_t nvme_ns_get_ctrl(nvme_ns_t n); + +/** + * nvme_free_ns() - Free a namespace object + * @n: Namespace instance + */ +void nvme_free_ns(struct nvme_ns *n); + +/** + * nvme_ns_read() - Read from a namespace + * @n: Namespace instance + * @buf: Buffer into which the data will be transferred + * @offset: LBA offset of @n + * @count: Number of sectors in @buf + * + * Return: Number of sectors read or -1 on error. + */ +int nvme_ns_read(nvme_ns_t n, void *buf, off_t offset, size_t count); + +/** + * nvme_ns_write() - Write to a namespace + * @n: Namespace instance + * @buf: Buffer with data to be written + * @offset: LBA offset of @n + * @count: Number of sectors in @buf + * + * Return: Number of sectors written or -1 on error + */ +int nvme_ns_write(nvme_ns_t n, void *buf, off_t offset, size_t count); + +/** + * nvme_ns_verify() - Verify data on a namespace + * @n: Namespace instance + * @offset: LBA offset of @n + * @count: Number of sectors to be verified + * + * Return: Number of sectors verified + */ +int nvme_ns_verify(nvme_ns_t n, off_t offset, size_t count); + +/** + * nvme_ns_compare() - Compare data on a namespace + * @n: Namespace instance + * @buf: Buffer with data to be compared + * @offset: LBA offset of @n + * @count: Number of sectors in @buf + * + * Return: Number of sectors compared + */ +int nvme_ns_compare(nvme_ns_t n, void *buf, off_t offset, size_t count); + +/** + * nvme_ns_write_zeros() - Write zeros to a namespace + * @n: Namespace instance + * @offset: LBA offset in @n + * @count: Number of sectors to be written + * + * Return: Number of sectors written + */ +int nvme_ns_write_zeros(nvme_ns_t n, off_t offset, size_t count); + +/** + * nvme_ns_write_uncorrectable() - Issus a 'write uncorrectable' command + * @n: Namespace instance + * @offset: LBA offset in @n + * @count: Number of sectors to be written + * + * Return: Number of sectors written + */ +int nvme_ns_write_uncorrectable(nvme_ns_t n, off_t offset, size_t count); + +/** + * nvme_ns_flush() - Flush data to a namespace + * @n: Namespace instance + * + * Return: 0 on success, -1 on error. + */ +int nvme_ns_flush(nvme_ns_t n); + +/** + * nvme_ns_identify() - Issue an 'identify namespace' command + * @n: Namespace instance + * @ns: &nvme_id_ns buffer + * + * Writes the data returned by the 'identify namespace' command + * into @ns. + * + * Return: 0 on success, -1 on error. + */ +int nvme_ns_identify(nvme_ns_t n, struct nvme_id_ns *ns); + +/** + * nvme_ns_identify_descs() - Issue an 'identify descriptors' command + * @n: Namespace instance + * @descs: List of identify descriptors + * + * Writes the data returned by the 'identify descriptors' command + * into @descs. + * + * Return: 0 on success, -1 on error. + */ +int nvme_ns_identify_descs(nvme_ns_t n, struct nvme_ns_id_desc *descs); + +/** + * nvme_path_get_name() - sysfs name of an &nvme_path_t object + * @p: &nvme_path_t object + * + * Return: sysfs name of @p + */ +const char *nvme_path_get_name(nvme_path_t p); + +/** + * nvme_path_get_sysfs_dir() - sysfs directory of an nvme_path_t object + * @p: &nvme_path_t object + * + * Return: sysfs directory of @p + */ +const char *nvme_path_get_sysfs_dir(nvme_path_t p); + +/** + * nvme_path_get_ana_state() - ANA state of an nvme_path_t object + * @p: &nvme_path_t object + * + * Return: ANA (Asynchronous Namespace Access) state of @p + */ +const char *nvme_path_get_ana_state(nvme_path_t p); + +/** + * nvme_path_get_ctrl() - Parent controller of an nvme_path_t object + * @p: &nvme_path_t object + * + * Return: Parent controller if present + */ +nvme_ctrl_t nvme_path_get_ctrl(nvme_path_t p); + +/** + * nvme_path_get_ns() - Parent namespace of an nvme_path_t object + * @p: &nvme_path_t object + * + * Return: Parent namespace if present + */ +nvme_ns_t nvme_path_get_ns(nvme_path_t p); + +/** + * nvme_ctrl_get_fd() - Get associated file descriptor + * @c: Controller instance + * + * Return: File descriptor associated with @c or -1 + */ +int nvme_ctrl_get_fd(nvme_ctrl_t c); + +/** + * nvme_ctrl_get_name() - sysfs name of a controller + * @c: Controller instance + * + * Return: sysfs name of @c + */ +const char *nvme_ctrl_get_name(nvme_ctrl_t c); + +/** + * nvme_ctrl_get_sysfs_dir() - sysfs directory of a controller + * @c: Controller instance + * + * Return: sysfs directory name of @c + */ +const char *nvme_ctrl_get_sysfs_dir(nvme_ctrl_t c); + +/** + * nvme_ctrl_get_address() - Address string of a controller + * @c: Controller instance + * + * Return: NVMe-over-Fabrics address string of @c or empty string + * of no address is present. + */ +const char *nvme_ctrl_get_address(nvme_ctrl_t c); + +/** + * nvme_ctrl_get_firmware() - Firmware string of a controller + * @c: Controller instance + * + * Return: Firmware string of @c + */ +const char *nvme_ctrl_get_firmware(nvme_ctrl_t c); + +/** + * nvme_ctrl_get_model() - Model of a controller + * @c: Controller instance + * + * Return: Model string of @c + */ +const char *nvme_ctrl_get_model(nvme_ctrl_t c); + +/** + * nvme_ctrl_get_state() - Running state of an controller + * @c: Controller instance + * + * Return: String indicating the running state of @c + */ +const char *nvme_ctrl_get_state(nvme_ctrl_t c); + +/** + * nvme_ctrl_get_numa_node() - NUMA node of a controller + * @c: Controller instance + * + * Return: String indicating the NUMA node + */ +const char *nvme_ctrl_get_numa_node(nvme_ctrl_t c); + +/** + * nvme_ctrl_get_queue_count() - Queue count of a controller + * @c: Controller instance + * + * Return: Queue count of @c + */ +const char *nvme_ctrl_get_queue_count(nvme_ctrl_t c); + +/** + * nvme_ctrl_get_serial() - Serial number of a controller + * @c: Conroller instance + * + * Return: Serial number string of @c + */ +const char *nvme_ctrl_get_serial(nvme_ctrl_t c); + +/** + * nvme_ctrl_get_sqsize() - SQ size of a controller + * @c: Controller instance + * + * Return: SQ size (as string) of @c + */ +const char *nvme_ctrl_get_sqsize(nvme_ctrl_t c); + +/** + * nvme_ctrl_get_transport() - Transport type of a controller + * @c: Controller instance + * + * Return: Transport type of @c + */ +const char *nvme_ctrl_get_transport(nvme_ctrl_t c); + +/** + * nvme_ctrl_get_subsysnqn() - Subsystem NQN of a controller + * @c: Controller instance + * + * Return: Subsystem NQN of @c + */ +const char *nvme_ctrl_get_subsysnqn(nvme_ctrl_t c); + +/** + * nvme_ctrl_get_subsystem() - Parent subsystem of a controller + * @c: Controller instance + * + * Return: Parent nvme_subsystem_t object + */ +nvme_subsystem_t nvme_ctrl_get_subsystem(nvme_ctrl_t c); + +/** + * nvme_ctrl_get_traddr() - Transport address of a controller + * @c: Controller instance + * + * Return: Transport address of @c + */ +const char *nvme_ctrl_get_traddr(nvme_ctrl_t c); + +/** + * nvme_ctrl_get_trsvcid() - Transport service identifier of a controller + * @c: Controller instance + * + * Return: Transport service identifier of @c (if present) + */ +const char *nvme_ctrl_get_trsvcid(nvme_ctrl_t c); + +/** + * nvme_ctrl_get_host_traddr() - Host transport address of a controller + * @c: Controller instance + * + * Return: Host transport address of @c (if present) + */ +const char *nvme_ctrl_get_host_traddr(nvme_ctrl_t c); + +/** + * nvme_ctrl_get_host_iface() - Host interface name of a controller + * @c: Controller instance + * + * Return: Host interface name of @c (if present) + */ +const char *nvme_ctrl_get_host_iface(nvme_ctrl_t c); + +/** + * nvme_ctrl_get_dhchap_key() - Return controller key + * @c: Controller for which the key should be set + * + * Return: DH-HMAC-CHAP controller key or NULL if not set + */ +const char *nvme_ctrl_get_dhchap_key(nvme_ctrl_t c); + +/** + * nvme_ctrl_set_dhchap_key() - Set controller key + * @c: Controller for which the key should be set + * @key: DH-HMAC-CHAP Key to set or NULL to clear existing key + */ +void nvme_ctrl_set_dhchap_key(nvme_ctrl_t c, const char *key); + +/** + * nvme_ctrl_get_config() - Fabrics configuration of a controller + * @c: Controller instance + * + * Return: Fabrics configuration of @c + */ +struct nvme_fabrics_config *nvme_ctrl_get_config(nvme_ctrl_t c); + +/** + * nvme_ctrl_set_discovered() - Set the 'discovered' flag + * @c: nvme_ctrl_t object + * @discovered: Value of the 'discovered' flag + * + * Set the 'discovered' flag of @c to @discovered + */ +void nvme_ctrl_set_discovered(nvme_ctrl_t c, bool discovered); + +/** + * nvme_ctrl_is_discovered() - Returns the value of the 'discovered' flag + * @c: Controller instance + * + * Return: Value of the 'discovered' flag of @c + */ +bool nvme_ctrl_is_discovered(nvme_ctrl_t c); + +/** + * nvme_ctrl_set_persistent() - Set the 'persistent' flag + * @c: Controller instance + * @persistent: value of the 'persistent' flag + * + * Set the 'persistent' flag of @c to @persistent + */ +void nvme_ctrl_set_persistent(nvme_ctrl_t c, bool persistent); + +/** + * nvme_ctrl_is_persistent() - Returns the value of the 'persistent' flag + * @c: Controller instance + * + * Return: Value of the 'persistent' flag of @c + */ +bool nvme_ctrl_is_persistent(nvme_ctrl_t c); + +/** + * nvme_ctrl_set_discovery_ctrl() - Set the 'discovery_ctrl' flag + * @c: Controller to be modified + * @discovery: value of the discovery_ctrl flag + * + * Sets the 'discovery_ctrl' flag in @c to specify whether + * @c connects to a discovery subsystem. + * + */ +void nvme_ctrl_set_discovery_ctrl(nvme_ctrl_t c, bool discovery); + +/** + * nvme_ctrl_is_discovery_ctrl() - Check the 'discovery_ctrl' flag + * @c: Controller to be checked + * + * Returns the value of the 'discovery_ctrl' flag which specifies whether + * @c connects to a discovery subsystem. + * + * Return: Value of the 'discover_ctrl' flag + */ +bool nvme_ctrl_is_discovery_ctrl(nvme_ctrl_t c); + +/** + * nvme_ctrl_identify() - Issues an 'identify controller' command + * @c: Controller instance + * @id: Identify controller data structure + * + * Issues an 'identify controller' command to @c and copies the + * data into @id. + * + * Return: 0 on success or -1 on failure. + */ +int nvme_ctrl_identify(nvme_ctrl_t c, struct nvme_id_ctrl *id); + +/** + * nvme_disconnect_ctrl() - Disconnect a controller + * @c: Controller instance + * + * Issues a 'disconnect' fabrics command to @c + * + * Return: 0 on success, -1 on failure. + */ +int nvme_disconnect_ctrl(nvme_ctrl_t c); + +/** + * nvme_scan_ctrl() - Scan on a controller + * @r: nvme_root_t object + * @name: Name of the controller + * + * Scans a controller with sysfs name @name and add it to @r. + * + * Return: nvme_ctrl_t object + */ +nvme_ctrl_t nvme_scan_ctrl(nvme_root_t r, const char *name); + +/** + * nvme_rescan_ctrl() - Rescan an existing controller + * @c: Controller instance + */ +void nvme_rescan_ctrl(nvme_ctrl_t c); + +/** + * nvme_init_ctrl() - Initialize nvme_ctrl_t object for an existing controller. + * @h: nvme_host_t object + * @c: nvme_ctrl_t object + * @instance: Instance number (e.g. 1 for nvme1) + * + * Return: The ioctl() return code. Typically 0 on success. + */ +int nvme_init_ctrl(nvme_host_t h, nvme_ctrl_t c, int instance); + +/** + * nvme_free_ctrl() - Free controller + * @c: Controller instance + */ +void nvme_free_ctrl(struct nvme_ctrl *c); + +/** + * nvme_unlink_ctrl() - Unlink controller + * @c: Controller instance + */ +void nvme_unlink_ctrl(struct nvme_ctrl *c); + +/** + * nvme_subsystem_get_nqn() - Retrieve NQN from subsystem + * @s: nvme_subsystem_t object + * + * Return: NQN of systemstem + */ +const char *nvme_subsystem_get_nqn(nvme_subsystem_t s); + +/** + * nvme_subsystem_get_sysfs_dir() - sysfs directory of an nvme_subsystem_t object + * @s: nvme_subsystem_t object + * + * Return: sysfs directory name of @s + */ +const char *nvme_subsystem_get_sysfs_dir(nvme_subsystem_t s); + +/** + * nvme_subsystem_get_name() - sysfs name of an nvme_subsystem_t object + * @s: nvme_subsystem_t object + * + * Return: sysfs name of @s + */ +const char *nvme_subsystem_get_name(nvme_subsystem_t s); + +/** + * nvme_subsystem_get_type() - Returns the type of a subsystem + * @s: nvme_subsystem_t object + * + * Returns the subsystem type of @s. + * + * Return: 'nvm' or 'discovery' + */ +const char *nvme_subsystem_get_type(nvme_subsystem_t s); + +/** + * nvme_scan_topology() - Scan NVMe topology and apply filter + * @r: nvme_root_t object + * @f: filter to apply + * @f_args: user-specified argument to @f + * + * Scans the NVMe topology and filters out the resulting elements + * by applying @f. + * + * Return: Number of elements scanned + */ +int nvme_scan_topology(nvme_root_t r, nvme_scan_filter_t f, void *f_args); + +/** + * nvme_host_get_hostnqn() - Host NQN of an nvme_host_t object + * @h: nvme_host_t object + * + * Return: Host NQN of @h + */ +const char *nvme_host_get_hostnqn(nvme_host_t h); + +/** + * nvme_host_get_hostid() - Host ID of an nvme_host_t object + * @h: nvme_host_t object + * + * Return: Host ID of @h + */ +const char *nvme_host_get_hostid(nvme_host_t h); + +/** + * nvme_free_host() - Free nvme_host_t object + * @h: nvme_host_t object + */ +void nvme_free_host(nvme_host_t h); + +/** + * nvme_scan() - Scan NVMe topology + * @config_file: Configuration file + * + * Return: nvme_root_t object of found elements + */ +nvme_root_t nvme_scan(const char *config_file); + +/** + * nvme_read_config() - Read NVMe JSON configuration file + * @r: nvme_root_t object + * @config_file: JSON configuration file + * + * Read in the contents of @config_file and merge them with + * the elements in @r. + * + * Returns: 0 on success, -1 on failure with errno set. + */ +int nvme_read_config(nvme_root_t r, const char *config_file); + +/** + * nvme_refresh_topology() - Refresh nvme_root_t object contents + * @r: nvme_root_t object + * + * Removes all elements in @r and rescans the existing topology. + */ +void nvme_refresh_topology(nvme_root_t r); + +/** + * nvme_update_config() - Update JSON configuration + * @r: nvme_root_t object + * + * Updates the JSON configuration file with the contents of @r. + * + * Return: 0 on success, -1 on failure. + */ +int nvme_update_config(nvme_root_t r); + +/** + * nvme_dump_config() - Print the JSON configuration + * @r: nvme_root_t object + * + * Prints the current contents of the JSON configuration + * file to stdout. + * + * Return: 0 on success, -1 on failure. + */ +int nvme_dump_config(nvme_root_t r); + +/** + * nvme_dump_tree() - Dump internal object tree + * @r: nvme_root_t object + * + * Prints the internal object tree in JSON format + * to stdout. + * + * Return: 0 on success, -1 on failure. + */ +int nvme_dump_tree(nvme_root_t r); + +/** + * nvme_get_attr() - Read sysfs attribute + * @d: sysfs directory + * @attr: sysfs attribute name + * + * Return: String with the contents of @attr or %NULL in case of an empty value + * or in case of an error (indicated by non-zero errno code). + */ +char *nvme_get_attr(const char *d, const char *attr); + +/** + * nvme_get_subsys_attr() - Read subsystem sysfs attribute + * @s: nvme_subsystem_t object + * @attr: sysfs attribute name + * + * Return: String with the contents of @attr or %NULL in case of an empty value + * or in case of an error (indicated by non-zero errno code). + */ +char *nvme_get_subsys_attr(nvme_subsystem_t s, const char *attr); + +/** + * nvme_get_ctrl_attr() - Read controller sysfs attribute + * @c: Controller instance + * @attr: sysfs attribute name + * + * Return: String with the contents of @attr or %NULL in case of an empty value + * or in case of an error (indicated by non-zero errno code). + */ +char *nvme_get_ctrl_attr(nvme_ctrl_t c, const char *attr); + +/** + * nvme_get_ns_attr() - Read namespace sysfs attribute + * @n: nvme_ns_t object + * @attr: sysfs attribute name + * + * Return: String with the contents of @attr or %NULL in case of an empty value + * or in case of an error (indicated by non-zero errno code). + */ +char *nvme_get_ns_attr(nvme_ns_t n, const char *attr); + +/** + * nvme_subsystem_lookup_namespace() - lookup namespace by NSID + * @s: nvme_subsystem_t object + * @nsid: Namespace id + * + * Return: nvme_ns_t of the namespace with id @nsid in subsystem @s + */ +nvme_ns_t nvme_subsystem_lookup_namespace(struct nvme_subsystem *s, + __u32 nsid); + +/** + * nvme_get_path_attr() - Read path sysfs attribute + * @p: nvme_path_t object + * @attr: sysfs attribute name + * + * Return: String with the contents of @attr or %NULL in case of an empty value + * or in case of an error (indicated by non-zero errno code). + */ +char *nvme_get_path_attr(nvme_path_t p, const char *attr); + +/** + * nvme_scan_namespace() - scan namespace based on sysfs name + * @name: sysfs name of the namespace to scan + * + * Return: nvme_ns_t object or NULL if not found. + */ +nvme_ns_t nvme_scan_namespace(const char *name); + +/** + * nvme_host_get_hostsymname() - Get the host's symbolic name + * @h: Host for which the symbolic name should be returned. + * + * Return: The symbolic name or NULL if a symbolic name hasn't been + * configure. + */ +const char *nvme_host_get_hostsymname(nvme_host_t h); + +/** + * nvme_host_set_hostsymname() - Set the host's symbolic name + * @h: Host for which the symbolic name should be set. + * @hostsymname: Symbolic name + */ +void nvme_host_set_hostsymname(nvme_host_t h, const char *hostsymname); + +#endif /* _LIBNVME_TREE_H */ diff --git a/src/nvme/types.h b/src/nvme/types.h new file mode 100644 index 0000000..84acb01 --- /dev/null +++ b/src/nvme/types.h @@ -0,0 +1,7069 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/* + * This file is part of libnvme. + * Copyright (c) 2020 Western Digital Corporation or its affiliates. + * + * Authors: Keith Busch <keith.busch@wdc.com> + * Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com> + */ + +#ifndef _LIBNVME_TYPES_H +#define _LIBNVME_TYPES_H + +#include <stdbool.h> +#include <stdint.h> + +#include <linux/types.h> + +/** + * DOC: types.h + * + * NVMe standard definitions + */ + +/** + * NVME_GET() - extract field from complex value + * @value: The original value of a complex field + * @name: The name of the sub-field within an nvme value + * + * By convention, this library defines _SHIFT and _MASK such that mask can be + * applied after the shift to isolate a specific set of bits that decode to a + * sub-field. + * + * Returns: The 'name' field from 'value' + */ +#define NVME_GET(value, name) \ + (((value) >> NVME_##name##_SHIFT) & NVME_##name##_MASK) + +/** + * NVME_SET() - set field into complex value + * @value: The value to be set in its completed position + * @name: The name of the sub-field within an nvme value + * + * Returns: The 'name' field from 'value' + */ +#define NVME_SET(value, name) \ + (((value) & NVME_##name##_MASK) << NVME_##name##_SHIFT) + +/** + * enum nvme_constants - A place to stash various constant nvme values + * @NVME_NSID_ALL: A broadcast value that is used to specify all + * namespaces + * @NVME_NSID_NONE: The invalid namespace id, for when the nsid + * parameter is not used in a command + * @NVME_UUID_NONE: Use to omit a uuid command parameter + * @NVME_CNTLID_NONE: Use to omit a cntlid command parameter + * @NVME_CNSSPECID_NONE: Use to omit a cns_specific_id command parameter + * @NVME_LOG_LSP_NONE: Use to omit a log lsp command parameter + * @NVME_LOG_LSI_NONE: Use to omit a log lsi command parameter + * @NVME_LOG_LPO_NONE: Use to omit a log lpo command parameter + * @NVME_IDENTIFY_DATA_SIZE: The transfer size for nvme identify commands + * @NVME_LOG_SUPPORTED_LOG_PAGES_MAX: The lagest possible index in the supported + * log pages log. + * @NVME_ID_NVMSET_LIST_MAX: The largest possible nvmset index in identify + * nvmeset + * @NVME_ID_UUID_LIST_MAX: The largest possible uuid index in identify + * uuid list + * @NVME_ID_CTRL_LIST_MAX: The largest possible controller index in + * identify controller list + * @NVME_ID_NS_LIST_MAX: The largest possible namespace index in + * identify namespace list + * @NVME_ID_SECONDARY_CTRL_MAX: The largest possible secondary controller index + * in identify secondary controller + * @NVME_ID_DOMAIN_LIST_MAX: The largest possible domain index in the + * in domain list + * @NVME_ID_ENDURANCE_GROUP_LIST_MAX: The largest possible endurance group + * index in the endurance group list + * @NVME_ID_ND_DESCRIPTOR_MAX: The largest possible namespace granularity + * index in the namespace granularity descriptor + * list + * @NVME_FEAT_LBA_RANGE_MAX: The largest possible LBA range index in feature + * lba range type + * @NVME_LOG_ST_MAX_RESULTS: The largest possible self test result index in the + * device self test log + * @NVME_LOG_FID_SUPPORTED_EFFECTS_MAX: The largest possible FID index in the + * feature identifiers effects log. + * @NVME_LOG_MI_CMD_SUPPORTED_EFFECTS_MAX: The largest possible MI Command index + * in the MI Command effects log. + * @NVME_LOG_MI_CMD_SUPPORTED_EFFECTS_RESERVED: The reserved space in the MI Command + * effects log. + * @NVME_LOG_TELEM_BLOCK_SIZE: Specification defined size of Telemetry Data Blocks + * @NVME_DSM_MAX_RANGES: The largest possible range index in a data-set + * management command + * @NVME_NQN_LENGTH: Max length for NVMe Qualified Name + * @NVMF_TRADDR_SIZE: Max Transport Address size + * @NVMF_TSAS_SIZE: Max Transport Specific Address Subtype size + * @NVME_ZNS_CHANGED_ZONES_MAX: Max number of zones in the changed zones log + * page + */ +enum nvme_constants { + NVME_NSID_ALL = 0xffffffff, + NVME_NSID_NONE = 0, + NVME_UUID_NONE = 0, + NVME_CNTLID_NONE = 0, + NVME_CNSSPECID_NONE = 0, + NVME_LOG_LSP_NONE = 0, + NVME_LOG_LSI_NONE = 0, + NVME_LOG_LPO_NONE = 0, + NVME_IDENTIFY_DATA_SIZE = 4096, + NVME_LOG_SUPPORTED_LOG_PAGES_MAX = 256, + NVME_ID_NVMSET_LIST_MAX = 31, + NVME_ID_UUID_LIST_MAX = 127, + NVME_ID_CTRL_LIST_MAX = 2047, + NVME_ID_NS_LIST_MAX = 1024, + NVME_ID_SECONDARY_CTRL_MAX = 127, + NVME_ID_DOMAIN_LIST_MAX = 31, + NVME_ID_ENDURANCE_GROUP_LIST_MAX = 2047, + NVME_ID_ND_DESCRIPTOR_MAX = 16, + NVME_FEAT_LBA_RANGE_MAX = 64, + NVME_LOG_ST_MAX_RESULTS = 20, + NVME_LOG_TELEM_BLOCK_SIZE = 512, + NVME_LOG_FID_SUPPORTED_EFFECTS_MAX = 256, + NVME_LOG_MI_CMD_SUPPORTED_EFFECTS_MAX = 256, + NVME_LOG_MI_CMD_SUPPORTED_EFFECTS_RESERVED = 768, + NVME_DSM_MAX_RANGES = 256, + NVME_NQN_LENGTH = 256, + NVMF_TRADDR_SIZE = 256, + NVMF_TSAS_SIZE = 256, + NVME_ZNS_CHANGED_ZONES_MAX = 511, +}; + +/** + * enum nvme_csi - Defined command set indicators + * @NVME_CSI_NVM: NVM Command Set Indicator + * @NVME_CSI_KV: Key Value Command Set + * @NVME_CSI_ZNS: Zoned Namespace Command Set + */ +enum nvme_csi { + NVME_CSI_NVM = 0, + NVME_CSI_KV = 1, + NVME_CSI_ZNS = 2, +}; + +/** + * enum nvme_register_offsets - controller registers for all transports. This + * is the layout of BAR0/1 for PCIe, and + * properties for fabrics. + * @NVME_REG_CAP: Controller Capabilities + * @NVME_REG_VS: Version + * @NVME_REG_INTMS: Interrupt Mask Set + * @NVME_REG_INTMC: Interrupt Mask Clear + * @NVME_REG_CC: Controller Configuration + * @NVME_REG_CSTS: Controller Status + * @NVME_REG_NSSR: NVM Subsystem Reset + * @NVME_REG_AQA: Admin Queue Attributes + * @NVME_REG_ASQ: Admin SQ Base Address + * @NVME_REG_ACQ: Admin CQ Base Address + * @NVME_REG_CMBLOC: Controller Memory Buffer Location + * @NVME_REG_CMBSZ: Controller Memory Buffer Size + * @NVME_REG_BPINFO: Boot Partition Information + * @NVME_REG_BPRSEL: Boot Partition Read Select + * @NVME_REG_BPMBL: Boot Partition Memory Buffer Location + * @NVME_REG_CMBMSC: Controller Memory Buffer Memory Space Control + * @NVME_REG_CMBSTS: Controller Memory Buffer Status + * @NVME_REG_PMRCAP: Persistent Memory Capabilities + * @NVME_REG_PMRCTL: Persistent Memory Region Control + * @NVME_REG_PMRSTS: Persistent Memory Region Status + * @NVME_REG_PMREBS: Persistent Memory Region Elasticity Buffer Size + * @NVME_REG_PMRSWTP: Memory Region Sustained Write Throughput + * @NVME_REG_PMRMSCL: Persistent Memory Region Controller Memory Space Control Lower + * @NVME_REG_PMRMSCU: Persistent Memory Region Controller Memory Space Control Upper + */ +enum nvme_register_offsets { + NVME_REG_CAP = 0x0000, + NVME_REG_VS = 0x0008, + NVME_REG_INTMS = 0x000c, + NVME_REG_INTMC = 0x0010, + NVME_REG_CC = 0x0014, + NVME_REG_CSTS = 0x001c, + NVME_REG_NSSR = 0x0020, + NVME_REG_AQA = 0x0024, + NVME_REG_ASQ = 0x0028, + NVME_REG_ACQ = 0x0030, + NVME_REG_CMBLOC = 0x0038, + NVME_REG_CMBSZ = 0x003c, + NVME_REG_BPINFO = 0x0040, + NVME_REG_BPRSEL = 0x0044, + NVME_REG_BPMBL = 0x0048, + NVME_REG_CMBMSC = 0x0050, + NVME_REG_CMBSTS = 0x0058, + NVME_REG_PMRCAP = 0x0e00, + NVME_REG_PMRCTL = 0x0e04, + NVME_REG_PMRSTS = 0x0e08, + NVME_REG_PMREBS = 0x0e0c, + NVME_REG_PMRSWTP = 0x0e10, + NVME_REG_PMRMSCL = 0x0e14, + NVME_REG_PMRMSCU = 0x0e18, +}; + +/** + * nvme_is_64bit_reg() - Checks if offset of the controller register is a know + * 64bit value. + * @offset: Offset of controller register field in bytes + * + * This function does not care about transport so that the offset is not going + * to be checked inside of this function for the unsupported fields in a + * specific transport. For example, BPMBL(Boot Partition Memory Buffer + * Location) register is not supported by fabrics, but it can be checked here. + * + * Returns true if given offset is 64bit register, otherwise it returns false. + */ +static inline bool nvme_is_64bit_reg(__u32 offset) +{ + switch (offset) { + case NVME_REG_CAP: + case NVME_REG_ASQ: + case NVME_REG_ACQ: + case NVME_REG_BPMBL: + case NVME_REG_CMBMSC: + return true; + default: + return false; + } +} + +enum nvme_cap { + NVME_CAP_MQES_SHIFT = 0, + NVME_CAP_CQR_SHIFT = 16, + NVME_CAP_AMS_SHIFT = 17, + NVME_CAP_TO_SHIFT = 24, + NVME_CAP_DSTRD_SHIFT = 32, + NVME_CAP_NSSRC_SHIFT = 36, + NVME_CAP_CSS_SHIFT = 37, + NVME_CAP_BPS_SHIFT = 45, + NVME_CAP_MPSMIN_SHIFT = 48, + NVME_CAP_MPSMAX_SHIFT = 52, + NVME_CAP_PMRS_SHIFT = 56, + NVME_CAP_CMBS_SHIFT = 57, + NVME_CAP_MQES_MASK = 0xffff, + NVME_CAP_CQR_MASK = 0x1, + NVME_CAP_AMS_MASK = 0x3, + NVME_CAP_TO_MASK = 0xff, + NVME_CAP_DSTRD_MASK = 0xf, + NVME_CAP_NSSRC_MASK = 0x1, + NVME_CAP_CSS_MASK = 0xff, + NVME_CAP_BPS_MASK = 0x1, + NVME_CAP_MPSMIN_MASK = 0xf, + NVME_CAP_MPSMAX_MASK = 0xf, + NVME_CAP_PMRS_MASK = 0x1, + NVME_CAP_CMBS_MASK = 0x1, + NVME_CAP_AMS_WRR = 1 << 0, + NVME_CAP_AMS_VS = 1 << 1, + NVME_CAP_CSS_NVM = 1 << 0, + NVME_CAP_CSS_CSI = 1 << 6, + NVME_CAP_CSS_ADMIN = 1 << 7, +}; + +#define NVME_CAP_MQES(cap) NVME_GET(cap, CAP_MQES) +#define NVME_CAP_CQR(cap) NVME_GET(cap, CAP_CQR) +#define NVME_CAP_AMS(cap) NVME_GET(cap, CAP_AMS) +#define NVME_CAP_TO(cap) NVME_GET(cap, CAP_TO) +#define NVME_CAP_DSTRD(cap) NVME_GET(cap, CAP_DSTRD) +#define NVME_CAP_NSSRC(cap) NVME_GET(cap, CAP_NSSRC) +#define NVME_CAP_CSS(cap) NVME_GET(cap, CAP_CSS) +#define NVME_CAP_BPS(cap) NVME_GET(cap, CAP_BPS) +#define NVME_CAP_MPSMIN(cap) NVME_GET(cap, CAP_MPSMIN) +#define NVME_CAP_MPSMAX(cap) NVME_GET(cap, CAP_MPSMAX) +#define NVME_CAP_CMBS(cap) NVME_GET(cap, CAP_CMBS) +#define NVME_CAP_PMRS(cap) NVME_GET(cap, CAP_PMRS) + +enum nvme_vs { + NVME_VS_TER_SHIFT = 0, + NVME_VS_MNR_SHIFT = 8, + NVME_VS_MJR_SHIFT = 16, + NVME_VS_TER_MASK = 0xff, + NVME_VS_MNR_MASK = 0xff, + NVME_VS_MJR_MASK = 0xffff, +}; + +#define NVME_VS_TER(vs) NVME_GET(vs, VS_TER) +#define NVME_VS_MNR(vs) NVME_GET(vs, VS_MNR) +#define NVME_VS_MJR(vs) NVME_GET(vs, VS_MJR) + +#define NVME_MAJOR(ver) NVME_VS_MJR(ver) +#define NVME_MINOR(ver) NVME_VS_MNR(ver) +#define NVME_TERTIARY(ver) NVME_VS_TER(ver) + +enum nvme_cc { + NVME_CC_EN_SHIFT = 0, + NVME_CC_CSS_SHIFT = 4, + NVME_CC_MPS_SHIFT = 7, + NVME_CC_AMS_SHIFT = 11, + NVME_CC_SHN_SHIFT = 14, + NVME_CC_IOSQES_SHIFT = 16, + NVME_CC_IOCQES_SHIFT = 20, + NVME_CC_EN_MASK = 0x1, + NVME_CC_CSS_MASK = 0x7, + NVME_CC_MPS_MASK = 0xf, + NVME_CC_AMS_MASK = 0x7, + NVME_CC_SHN_MASK = 0x3, + NVME_CC_IOSQES_MASK = 0xf, + NVME_CC_IOCQES_MASK = 0xf, + NVME_CC_CSS_NVM = 0, + NVME_CC_CSS_CSI = 6, + NVME_CC_CSS_ADMIN = 7, + NVME_CC_AMS_RR = 0, + NVME_CC_AMS_WRRU = 1, + NVME_CC_AMS_VS = 7, + NVME_CC_SHN_NONE = 0, + NVME_CC_SHN_NORMAL = 1, + NVME_CC_SHN_ABRUPT = 2, +}; + +#define NVME_CC_EN(cc) NVME_GET(cc, CC_EN) +#define NVME_CC_CSS(cc) NVME_GET(cc, CC_CSS) +#define NVME_CC_MPS(cc) NVME_GET(cc, CC_MPS) +#define NVME_CC_AMS(cc) NVME_GET(cc, CC_AMS) +#define NVME_CC_SHN(cc) NVME_GET(cc, CC_SHN) +#define NVME_CC_IOSQES(cc) NVME_GET(cc, CC_IOSQES) +#define NVME_CC_IOCQES(cc) NVME_GET(cc, CC_IOCQES) + +enum nvme_csts { + NVME_CSTS_RDY_SHIFT = 0, + NVME_CSTS_CFS_SHIFT = 1, + NVME_CSTS_SHST_SHIFT = 2, + NVME_CSTS_NSSRO_SHIFT = 4, + NVME_CSTS_PP_SHIFT = 5, + NVME_CSTS_RDY_MASK = 0x1, + NVME_CSTS_CFS_MASK = 0x1, + NVME_CSTS_SHN_MASK = 0x3, + NVME_CSTS_NSSRO_MASK = 0x1, + NVME_CSTS_PP_MASK = 0x1, + NVME_CSTS_SHST_NORMAL = 0, + NVME_CSTS_SHST_OCCUR = 1, + NVME_CSTS_SHST_CMPLT = 2, + NVME_CSTS_SHST_MASK = 3, +}; + +#define NVME_CSTS_RDY(csts) NVME_GET(csts, CSTS_RDY) +#define NVME_CSTS_CFS(csts) NVME_GET(csts, CSTS_CFS) +#define NVME_CSTS_SHST(csts) NVME_GET(csts, CSTS_SHST) +#define NVME_CSTS_NSSRO(csts) NVME_GET(csts, CSTS_NSSRO) +#define NVME_CSTS_PP(csts) NVME_GET(csts, CSTS_PP) + +enum nvme_aqa { + NVME_AQA_ASQS_SHIFT = 0, + NVME_AQA_ACQS_SHIFT = 16, + NVME_AQA_ASQS_MASK = 0xfff, + NVME_AQA_ACQS_MASK = 0xfff, +}; + +#define NVME_AQA_ASQS(aqa) NVME_GET(aqa, AQA_ASQS) +#define NVME_AQA_ACQS(aqa) NVME_GET(aqa, AQA_ACQS) + +enum nvme_cmbloc { + NVME_CMBLOC_BIR_SHIFT = 0, + NVME_CMBLOC_CQMMS_SHIFT = 3, + NVME_CMBLOC_CQPDS_SHIFT = 4, + NVME_CMBLOC_CDPLMS_SHIFT = 5, + NVME_CMBLOC_CDPCILS_SHIFT = 6, + NVME_CMBLOC_CDMMMS_SHIFT = 7, + NVME_CMBLOC_CQDA_SHIFT = 8, + NVME_CMBLOC_OFST_SHIFT = 12, + NVME_CMBLOC_BIR_MASK = 0x7, + NVME_CMBLOC_CQMMS_MASK = 0x1, + NVME_CMBLOC_CQPDS_MASK = 0x1, + NVME_CMBLOC_CDPLMS_MASK = 0x1, + NVME_CMBLOC_CDPCILS_MASK = 0x1, + NVME_CMBLOC_CDMMMS_MASK = 0x1, + NVME_CMBLOC_CQDA_MASK = 0x1, + NVME_CMBLOC_OFST_MASK = 0xfffff, +}; + +#define NVME_CMBLOC_BIR(cmbloc) NVME_GET(cmbloc, CMBLOC_BIR) +#define NVME_CMBLOC_CQMMS(cmbloc) NVME_GET(cmbloc, CMBLOC_CQMMS) +#define NVME_CMBLOC_CQPDS(cmbloc) NVME_GET(cmbloc, CMBLOC_CQPDS) +#define NVME_CMBLOC_CDPLMS(cmbloc) NVME_GET(cmbloc, CMBLOC_CDPLMS) +#define NVME_CMBLOC_CDPCILS(cmbloc) NVME_GET(cmbloc, CMBLOC_CDPCILS) +#define NVME_CMBLOC_CDMMMS(cmbloc) NVME_GET(cmbloc, CMBLOC_CDMMMS) +#define NVME_CMBLOC_CQDA(cmbloc) NVME_GET(cmbloc, CMBLOC_CQDA) +#define NVME_CMBLOC_OFST(cmbloc) NVME_GET(cmbloc, CMBLOC_OFST) + +enum nvme_cmbsz { + NVME_CMBSZ_SQS_SHIFT = 0, + NVME_CMBSZ_CQS_SHIFT = 1, + NVME_CMBSZ_LISTS_SHIFT = 2, + NVME_CMBSZ_RDS_SHIFT = 3, + NVME_CMBSZ_WDS_SHIFT = 4, + NVME_CMBSZ_SZU_SHIFT = 8, + NVME_CMBSZ_SZ_SHIFT = 12, + NVME_CMBSZ_SQS_MASK = 0x1, + NVME_CMBSZ_CQS_MASK = 0x1, + NVME_CMBSZ_LISTS_MASK = 0x1, + NVME_CMBSZ_RDS_MASK = 0x1, + NVME_CMBSZ_WDS_MASK = 0x1, + NVME_CMBSZ_SZU_MASK = 0xf, + NVME_CMBSZ_SZ_MASK = 0xfffff, + NVME_CMBSZ_SZU_4K = 0, + NVME_CMBSZ_SZU_64K = 1, + NVME_CMBSZ_SZU_1M = 2, + NVME_CMBSZ_SZU_16M = 3, + NVME_CMBSZ_SZU_256M = 4, + NVME_CMBSZ_SZU_4G = 5, + NVME_CMBSZ_SZU_64G = 6, +}; + +#define NVME_CMBSZ_SQS(cmbsz) NVME_GET(cmbsz, CMBSZ_SQS) +#define NVME_CMBSZ_CQS(cmbsz) NVME_GET(cmbsz, CMBSZ_CQS) +#define NVME_CMBSZ_LISTS(cmbsz) NVME_GET(cmbsz, CMBSZ_LISTS) +#define NVME_CMBSZ_RDS(cmbsz) NVME_GET(cmbsz, CMBSZ_RDS) +#define NVME_CMBSZ_WDS(cmbsz) NVME_GET(cmbsz, CMBSZ_WDS) +#define NVME_CMBSZ_SZU(cmbsz) NVME_GET(cmbsz, CMBSZ_SZU) +#define NVME_CMBSZ_SZ(cmbsz) NVME_GET(cmbsz, CMBSZ_SZ) + +/** + * nvme_cmb_size() - Calculate size of the controller memory buffer + * @cmbsz: Value from controller register %NVME_REG_CMBSZ + * + * Returns size of controller memory buffer in bytes + */ +static inline __u64 nvme_cmb_size(__u32 cmbsz) +{ + return ((__u64)NVME_CMBSZ_SZ(cmbsz)) * + (1ULL << (12 + 4 * NVME_CMBSZ_SZU(cmbsz))); +} + +enum nvme_bpinfo { + NVME_BPINFO_BPSZ_SHIFT = 0, + NVME_BPINFO_BRS_SHIFT = 24, + NVME_BPINFO_ABPID_SHIFT = 31, + NVME_BPINFO_BPSZ_MASK = 0x7fff, + NVME_BPINFO_BRS_MASK = 0x3, + NVME_BPINFO_ABPID_MASK = 0x1, + NVME_BPINFO_BRS_NONE = 0, + NVME_BPINFO_BRS_READ_IN_PROGRESS = 1, + NVME_BPINFO_BRS_READ_SUCCESS = 2, + NVME_BPINFO_BRS_READ_ERROR = 3, +}; + +#define NVME_BPINFO_BPSZ(bpinfo) NVME_GET(bpinfo, BPINFO_BPSZ) +#define NVME_BPINFO_BRS(bpinfo) NVME_GET(bpinfo, BPINFO_BRS) +#define NVME_BPINFO_ABPID(bpinfo) NVME_GET(bpinfo, BPINFO_ABPID) + +enum nvme_bprsel { + NVME_BPRSEL_BPRSZ_SHIFT = 0, + NVME_BPRSEL_BPROF_SHIFT = 10, + NVME_BPRSEL_BPID_SHIFT = 31, + NVME_BPRSEL_BPRSZ_MASK = 0x3ff, + NVME_BPRSEL_BPROF_MASK = 0xfff, + NVME_BPRSEL_BPID_MASK = 0x1, +}; + +#define NVME_BPRSEL_BPRSZ(bprsel) NVME_GET(bprsel, BPRSEL_BPRSZ) +#define NVME_BPRSEL_BPROF(bprsel) NVME_GET(bprsel, BPRSEL_BPROF) +#define NVME_BPRSEL_BPID(bprsel) NVME_GET(bprsel, BPRSEL_BPID) + +enum nvme_cmbmsc { + NVME_CMBMSC_CRE_SHIFT = 0, + NVME_CMBMSC_CMSE_SHIFT = 1, + NVME_CMBMSC_CBA_SHIFT = 12, + NVME_CMBMSC_CRE_MASK = 0x1, + NVME_CMBMSC_CMSE_MASK = 0x1, +}; +static const __u64 NVME_CMBMSC_CBA_MASK = 0xfffffffffffffull; + +#define NVME_CMBMSC_CRE(cmbmsc) NVME_GET(cmbmsc, CMBMSC_CRE) +#define NVME_CMBMSC_CMSE(cmbmsc) NVME_GET(cmbmsc, CMBMSC_CMSE) +#define NVME_CMBMSC_CBA(cmbmsc) NVME_GET(cmbmsc, CMBMSC_CBA) + +enum nvme_cmbsts { + NVME_CMBSTS_CBAI_SHIFT = 0, + NVME_CMBSTS_CBAI_MASK = 0x1, +}; + +#define NVME_CMBSTS_CBAI(cmbsts) NVME_GET(cmbsts, CMBSTS_CBAI) + +enum nvme_pmrcap { + NVME_PMRCAP_RDS_SHIFT = 3, + NVME_PMRCAP_WDS_SHIFT = 4, + NVME_PMRCAP_BIR_SHIFT = 5, + NVME_PMRCAP_PMRTU_SHIFT = 8, + NVME_PMRCAP_PMRWMB_SHIFT = 10, + NVME_PMRCAP_PMRTO_SHIFT = 16, + NVME_PMRCAP_CMSS_SHIFT = 24, + NVME_PMRCAP_RDS_MASK = 0x1, + NVME_PMRCAP_WDS_MASK = 0x1, + NVME_PMRCAP_BIR_MASK = 0x7, + NVME_PMRCAP_PMRTU_MASK = 0x3, + NVME_PMRCAP_PMRWMB_MASK = 0xf, + NVME_PMRCAP_PMRTO_MASK = 0xff, + NVME_PMRCAP_CMSS_MASK = 0x1, + NVME_PMRCAP_PMRTU_500MS = 0, + NVME_PMRCAP_PMRTU_60S = 1, +}; + +#define NVME_PMRCAP_RDS(pmrcap) NVME_GET(pmrcap, PMRCAP_RDS) +#define NVME_PMRCAP_WDS(pmrcap) NVME_GET(pmrcap, PMRCAP_WDS) +#define NVME_PMRCAP_BIR(pmrcap) NVME_GET(pmrcap, PMRCAP_BIR) +#define NVME_PMRCAP_PMRTU(pmrcap) NVME_GET(pmrcap, PMRCAP_PMRTU) +#define NVME_PMRCAP_PMRWMB(pmrcap) NVME_GET(pmrcap, PMRCAP_PMRWMB) +#define NVME_PMRCAP_PMRTO(pmrcap) NVME_GET(pmrcap, PMRCAP_PMRTO) +#define NVME_PMRCAP_CMSS(pmrcap) NVME_GET(pmrcap, PMRCAP_CMSS) + +enum nvme_pmrctl { + NVME_PMRCTL_EN_SHIFT = 0, + NVME_PMRCTL_EN_MASK = 0x1, +}; + +#define NVME_PMRCTL_EN(pmrctl) NVME_GET(pmrctl, PMRCTL_EN) + +enum nvme_pmrsts { + NVME_PMRSTS_ERR_SHIFT = 0, + NVME_PMRSTS_NRDY_SHIFT = 8, + NVME_PMRSTS_HSTS_SHIFT = 9, + NVME_PMRSTS_CBAI_SHIFT = 12, + NVME_PMRSTS_ERR_MASK = 0xff, + NVME_PMRSTS_NRDY_MASK = 0x1, + NVME_PMRSTS_HSTS_MASK = 0x7, + NVME_PMRSTS_CBAI_MASK = 0x1, +}; + +#define NVME_PMRSTS_ERR(pmrsts) NVME_GET(pmrsts, PMRSTS_ERR) +#define NVME_PMRSTS_NRDY(pmrsts) NVME_GET(pmrsts, PMRSTS_NRDY) +#define NVME_PMRSTS_HSTS(pmrsts) NVME_GET(pmrsts, PMRSTS_HSTS) +#define NVME_PMRSTS_CBAI(pmrsts) NVME_GET(pmrsts, PMRSTS_CBAI) + +enum nvme_pmrebs { + NVME_PMREBS_PMRSZU_SHIFT = 0, + NVME_PMREBS_RBB_SHIFT = 4, + NVME_PMREBS_PMRWBZ_SHIFT = 8, + NVME_PMREBS_PMRSZU_MASK = 0xf, + NVME_PMREBS_RBB_MASK = 0x1, + NVME_PMREBS_PMRWBZ_MASK = 0xffffff, + NVME_PMREBS_PMRSZU_B = 0, + NVME_PMREBS_PMRSZU_1K = 1, + NVME_PMREBS_PMRSZU_1M = 2, + NVME_PMREBS_PMRSZU_1G = 3, +}; + +#define NVME_PMREBS_PMRSZU(pmrebs) NVME_GET(pmrebs, PMREBS_PMRSZU) +#define NVME_PMREBS_RBB(pmrebs) NVME_GET(pmrebs, PMREBS_RBB) +#define NVME_PMREBS_PMRWBZ(pmrebs) NVME_GET(pmrebs, PMREBS_PMRWBZ) + +/** + * nvme_pmr_size() - Calculate size of persistent memory region elasticity + * buffer + * @pmrebs: Value from controller register %NVME_REG_PMREBS + * + * Returns size of controller persistent memory buffer in bytes + */ +static inline __u64 nvme_pmr_size(__u32 pmrebs) +{ + return ((__u64)NVME_PMREBS_PMRWBZ(pmrebs)) * + (1ULL << (10 * NVME_PMREBS_PMRSZU(pmrebs))); +} + +enum nvme_pmrswtp { + NVME_PMRSWTP_PMRSWTU_SHIFT = 0, + NVME_PMRSWTP_PMRSWTV_SHIFT = 8, + NVME_PMRSWTP_PMRSWTU_MASK = 0xf, + NVME_PMRSWTP_PMRSWTV_MASK = 0xffffff, + NVME_PMRSWTP_PMRSWTU_BPS = 0, + NVME_PMRSWTP_PMRSWTU_KBPS = 1, + NVME_PMRSWTP_PMRSWTU_MBPS = 2, + NVME_PMRSWTP_PMRSWTU_GBPS = 3, +}; + +#define NVME_PMRSWTP_PMRSWTU(pmrswtp) NVME_GET(pmrswtp, PMRSWTP_PMRSWTU) +#define NVME_PMRSWTP_PMRSWTV(pmrswtp) NVME_GET(pmrswtp, PMRSWTP_PMRSWTU) + +/** + * nvme_pmr_throughput() - Calculate throughput of persistent memory buffer + * @pmrswtp: Value from controller register %NVME_REG_PMRSWTP + * + * Returns throughput of controller persistent memory buffer in bytes/second + */ +static inline __u64 nvme_pmr_throughput(__u32 pmrswtp) +{ + return ((__u64)NVME_PMRSWTP_PMRSWTV(pmrswtp)) * + (1ULL << (10 * NVME_PMRSWTP_PMRSWTU(pmrswtp))); +} + +enum nvme_pmrmsc { + NVME_PMRMSC_CMSE_SHIFT = 1, + NVME_PMRMSC_CBA_SHIFT = 12, + NVME_PMRMSC_CMSE_MASK = 0x1, +}; +static const __u64 NVME_PMRMSC_CBA_MASK = 0xfffffffffffffull; + +#define NVME_PMRMSC_CMSE(pmrmsc) NVME_GET(pmrmsc, PMRMSC_CMSE) +#define NVME_PMRMSC_CBA(pmrmsc) NVME_GET(pmrmsc, PMRMSC_CBA) + +/** + * enum nvme_psd_flags - Possible flag values in nvme power state descriptor + * @NVME_PSD_FLAGS_MXPS: Indicates the scale for the Maximum Power + * field. If this bit is cleared, then the scale of the + * Maximum Power field is in 0.01 Watts. If this bit is + * set, then the scale of the Maximum Power field is in + * 0.0001 Watts. + * @NVME_PSD_FLAGS_NOPS: Indicates whether the controller processes I/O + * commands in this power state. If this bit is cleared, + * then the controller processes I/O commands in this + * power state. If this bit is set, then the controller + * does not process I/O commands in this power state. + */ +enum nvme_psd_flags { + NVME_PSD_FLAGS_MXPS = 1 << 0, + NVME_PSD_FLAGS_NOPS = 1 << 1, +}; + +/** + * enum nvme_psd_ps - Known values for &struct nvme_psd %ips and %aps. Use with + * nvme_psd_power_scale() to extract the power scale field + * to match this enum. + * @NVME_PSD_PS_100_MICRO_WATT: 0.0001 watt scale + * @NVME_PSD_PS_10_MILLI_WATT: 0.01 watt scale + */ +enum nvme_psd_ps { + NVME_PSD_PS_100_MICRO_WATT = 1, + NVME_PSD_PS_10_MILLI_WATT = 2, +}; + +/** + * nvme_psd_power_scale() - power scale occupies the upper 3 bits + * @ps: power scale value + */ +static inline unsigned int nvme_psd_power_scale(__u8 ps) +{ + return ps >> 6; +} + +/** + * enum nvme_psd_workload - Specifies a workload hint in the Power Management + * Feature (see &struct nvme_psd.apw) to inform the + * NVM subsystem or indicate the conditions for the + * active power level. + * @NVME_PSD_WORKLOAD_1: Extended Idle Period with a Burst of Random Write + * consists of five minutes of idle followed by + * thirty-two random write commands of size 1 MiB + * submitted to a single controller while all other + * controllers in the NVM subsystem are idle, and then + * thirty (30) seconds of idle. + * @NVME_PSD_WORKLOAD_2: Heavy Sequential Writes consists of 80,000 + * sequential write commands of size 128 KiB submitted to + * a single controller while all other controllers in the + * NVM subsystem are idle. The submission queue(s) + * should be sufficiently large allowing the host to + * ensure there are multiple commands pending at all + * times during the workload. + */ +enum nvme_psd_workload { + NVME_PSD_WORKLOAD_1 = 1, + NVME_PSD_WORKLOAD_2 = 2, +}; + +/** + * struct nvme_id_psd - + * @mp: Maximum Power indicates the sustained maximum power consumed by the + * NVM subsystem in this power state. The power in Watts is equal to + * the value in this field multiplied by the scale specified in the Max + * Power Scale bit (see &enum nvme_psd_flags). A value of 0 indicates + * Maximum Power is not reported. + * @rsvd2: Reserved + * @flags: Additional decoding flags, see &enum nvme_psd_flags. + * @enlat: Entry Latency indicates the maximum latency in microseconds + * associated with entering this power state. A value of 0 indicates + * Entry Latency is not reported. + * @exlat: Exit Latency indicates the maximum latency in microseconds + * associated with exiting this power state. A value of 0 indicates + * Exit Latency is not reported. + * @rrt: Relative Read Throughput indicates the read throughput rank + * associated with this power state relative to others. The value in + * this is less than the number of supported power states. + * @rrl: Relative Reade Latency indicates the read latency rank associated + * with this power state relative to others. The value in this field is + * less than the number of supported power states. + * @rwt: Relative Write Throughput indicates write throughput rank associated + * with this power state relative to others. The value in this field is + * less than the number of supported power states + * @rwl: Relative Write Latency indicates the write latency rank associated + * with this power state relative to others. The value in this field is + * less than the number of supported power states + * @idlp: Idle Power indicates the typical power consumed by the NVM + * subsystem over 30 seconds in this power state when idle. + * @ips: Idle Power Scale indicates the scale for &struct nvme_id_psd.idlp, + * see &enum nvme_psd_ps for decoding this field. + * @rsvd19: Reserved + * @actp: Active Power indicates the largest average power consumed by the + * NVM subsystem over a 10 second period in this power state with + * the workload indicated in the Active Power Workload field. + * @apws: Bits 7-6: Active Power Scale(APS) indicates the scale for the &struct + * nvme_id_psd.actp, see &enum nvme_psd_ps for decoding this value. + * Bits 2-0: Active Power Workload(APW) indicates the workload + * used to calculate maximum power for this power state. + * See &enum nvme_psd_workload for decoding this field. + * @rsvd23: Reserved + */ +struct nvme_id_psd { + __le16 mp; + __u8 rsvd2; + __u8 flags; + __le32 enlat; + __le32 exlat; + __u8 rrt; + __u8 rrl; + __u8 rwt; + __u8 rwl; + __le16 idlp; + __u8 ips; + __u8 rsvd19; + __le16 actp; + __u8 apws; + __u8 rsvd23[9]; +}; + +/** + * struct nvme_id_ctrl - Identify Controller data structure + * @vid: PCI Vendor ID, the company vendor identifier that is assigned by + * the PCI SIG. + * @ssvid: PCI Subsystem Vendor ID, the company vendor identifier that is + * assigned by the PCI SIG for the subsystem. + * @sn: Serial Number in ascii + * @mn: Model Number in ascii + * @fr: Firmware Revision in ascii, the currently active firmware + * revision for the NVM subsystem + * @rab: Recommended Arbitration Burst, reported as a power of two + * @ieee: IEEE assigned Organization Unique Identifier + * @cmic: Controller Multipath IO and Namespace Sharing Capabilities of + * the controller and NVM subsystem. See &enum nvme_id_ctrl_cmic. + * @mdts: Max Data Transfer Size is the largest data transfer size. The + * host should not submit a command that exceeds this maximum data + * transfer size. The value is in units of the minimum memory page + * size (CAP.MPSMIN) and is reported as a power of two + * @cntlid: Controller ID, the NVM subsystem unique controller identifier + * associated with the controller. + * @ver: Version, this field contains the value reported in the Version + * register, or property (see &enum nvme_registers %NVME_REG_VS). + * @rtd3r: RTD3 Resume Latency, the expected latency in microseconds to resume + * from Runtime D3 + * @rtd3e: RTD3 Exit Latency, the typical latency in microseconds to enter + * Runtime D3. + * @oaes: Optional Async Events Supported, see @enum nvme_id_ctrl_oaes. + * @ctratt: Controller Attributes, see @enum nvme_id_ctrl_ctratt. + * @rrls: Read Recovery Levels. If a bit is set, then the corresponding + * Read Recovery Level is supported. If a bit is cleared, then the + * corresponding Read Recovery Level is not supported. + * @rsvd102: Reserved + * @cntrltype: Controller Type, see &enum nvme_id_ctrl_cntrltype + * @fguid: FRU GUID, a 128-bit value that is globally unique for a given + * Field Replaceable Unit + * @crdt1: Controller Retry Delay time in 100 millisecod units if CQE CRD + * field is 1 + * @crdt2: Controller Retry Delay time in 100 millisecod units if CQE CRD + * field is 2 + * @crdt3: Controller Retry Delay time in 100 millisecod units if CQE CRD + * field is 3 + * @rsvd134: Reserved + * @nvmsr: NVM Subsystem Report, see &enum nvme_id_ctrl_nvmsr + * @vwci: VPD Write Cycle Information, see &enum nvme_id_ctrl_vwci + * @mec: Management Endpoint Capabilities, see &enum nvme_id_ctrl_mec + * @oacs: Optional Admin Command Support,the optional Admin commands and + * features supported by the controller, see &enum nvme_id_ctrl_oacs. + * @acl: Abort Command Limit, the maximum number of concurrently + * executing Abort commands supported by the controller. This is a + * 0's based value. + * @aerl: Async Event Request Limit, the maximum number of concurrently + * outstanding Asynchronous Event Request commands supported by the + * controller This is a 0's based value. + * @frmw: Firmware Updates indicates capabilities regarding firmware + * updates. See &enum nvme_id_ctrl_frmw. + * @lpa: Log Page Attributes, see &enum nvme_id_ctrl_lpa. + * @elpe: Error Log Page Entries, the maximum number of Error Information + * log entries that are stored by the controller. This field is a + * 0's based value. + * @npss: Number of Power States Supported, the number of NVM Express + * power states supported by the controller, indicating the number + * of valid entries in &struct nvme_id_ctrl.psd. This is a 0's + * based value. + * @avscc: Admin Vendor Specific Command Configuration, see + * &enum nvme_id_ctrl_avscc. + * @apsta: Autonomous Power State Transition Attributes, see + * &enum nvme_id_ctrl_apsta. + * @wctemp: Warning Composite Temperature Threshold indicates + * the minimum Composite Temperature field value (see &struct + * nvme_smart_log.critical_comp_time) that indicates an overheating + * condition during which controller operation continues. + * @cctemp: Critical Composite Temperature Threshold, field indicates the + * minimum Composite Temperature field value (see &struct + * nvme_smart_log.critical_comp_time) that indicates a critical + * overheating condition. + * @mtfa: Maximum Time for Firmware Activation indicates the maximum time + * the controller temporarily stops processing commands to activate + * the firmware image, specified in 100 millisecond units. This + * field is always valid if the controller supports firmware + * activation without a reset. + * @hmpre: Host Memory Buffer Preferred Size indicates the preferred size + * that the host is requested to allocate for the Host Memory + * Buffer feature in 4 KiB units. + * @hmmin: Host Memory Buffer Minimum Size indicates the minimum size that + * the host is requested to allocate for the Host Memory Buffer + * feature in 4 KiB units. + * @tnvmcap: Total NVM Capacity, the total NVM capacity in the NVM subsystem. + * The value is in bytes. + * @unvmcap: Unallocated NVM Capacity, the unallocated NVM capacity in the + * NVM subsystem. The value is in bytes. + * @rpmbs: Replay Protected Memory Block Support, see + * &enum nvme_id_ctrl_rpmbs. + * @edstt: Extended Device Self-test Time, if Device Self-test command is + * supported (see &struct nvme_id_ctrl.oacs, %NVME_CTRL_OACS_SELF_TEST), + * then this field indicates the nominal amount of time in one + * minute units that the controller takes to complete an extended + * device self-test operation when in power state 0. + * @dsto: Device Self-test Options, see &enum nvme_id_ctrl_dsto. + * @fwug: Firmware Update Granularity indicates the granularity and + * alignment requirement of the firmware image being updated by the + * Firmware Image Download command. The value is reported in 4 KiB + * units. A value of 0h indicates no information on granularity is + * provided. A value of FFh indicates no restriction + * @kas: Keep Alive Support indicates the granularity of the Keep Alive + * Timer in 100 millisecond units. + * @hctma: Host Controlled Thermal Management Attributes, see + * &enum nvme_id_ctrl_hctm. + * @mntmt: Minimum Thermal Management Temperature indicates the minimum + * temperature, in degrees Kelvin, that the host may request in the + * Thermal Management Temperature 1 field and Thermal Management + * Temperature 2 field of a Set Features command with the Feature + * Identifier field set to %NVME_FEAT_FID_HCTM. + * @mxtmt: Maximum Thermal Management Temperature indicates the maximum + * temperature, in degrees Kelvin, that the host may request in the + * Thermal Management Temperature 1 field and Thermal Management + * Temperature 2 field of the Set Features command with the Feature + * Identifier set to %NVME_FEAT_FID_HCTM. + * @sanicap: Sanitize Capabilities, see &enum nvme_id_ctrl_sanicap + * @hmminds: Host Memory Buffer Minimum Descriptor Entry Size indicates the + * minimum usable size of a Host Memory Buffer Descriptor Entry in + * 4 KiB units. + * @hmmaxd: Host Memory Maximum Descriptors Entries indicates the number of + * usable Host Memory Buffer Descriptor Entries. + * @nsetidmax: NVM Set Identifier Maximum, defines the maximum value of a valid + * NVM Set Identifier for any controller in the NVM subsystem. + * @endgidmax: Endurance Group Identifier Maximum, defines the maximum value of + * a valid Endurance Group Identifier for any controller in the NVM + * subsystem. + * @anatt: ANA Transition Time indicates the maximum amount of time, in + * seconds, for a transition between ANA states or the maximum + * amount of time, in seconds, that the controller reports the ANA + * change state. + * @anacap: Asymmetric Namespace Access Capabilities, see + * &enum nvme_id_ctrl_anacap. + * @anagrpmax: ANA Group Identifier Maximum indicates the maximum value of a + * valid ANA Group Identifier for any controller in the NVM + * subsystem. + * @nanagrpid: Number of ANA Group Identifiers indicates the number of ANA + * groups supported by this controller. + * @pels: Persistent Event Log Size indicates the maximum reportable size + * for the Persistent Event Log. + * @domainid: Domain Identifier indicates the identifier of the domain + * that contains this controller. + * @rsvd358: Reserved + * @megcap: Max Endurance Group Capacity indicates the maximum capacity + * of a single Endurance Group. + * @rsvd384: Reserved + * @sqes: Submission Queue Entry Size, see &enum nvme_id_ctrl_sqes. + * @cqes: Completion Queue Entry Size, see &enum nvme_id_ctrl_cqes. + * @maxcmd: Maximum Outstanding Commands indicates the maximum number of + * commands that the controller processes at one time for a + * particular queue. + * @nn: Number of Namespaces indicates the maximum value of a valid + * nsid for the NVM subsystem. If the MNAN (&struct nvme_id_ctrl.mnan + * field is cleared to 0h, then this field also indicates the + * maximum number of namespaces supported by the NVM subsystem. + * @oncs: Optional NVM Command Support, see &enum nvme_id_ctrl_oncs. + * @fuses: Fused Operation Support, see &enum nvme_id_ctrl_fuses. + * @fna: Format NVM Attributes, see &enum nvme_id_ctrl_fna. + * @vwc: Volatile Write Cache, see &enum nvme_id_ctrl_vwc. + * @awun: Atomic Write Unit Normal indicates the size of the write + * operation guaranteed to be written atomically to the NVM across + * all namespaces with any supported namespace format during normal + * operation. This field is specified in logical blocks and is a + * 0's based value. + * @awupf: Atomic Write Unit Power Fail indicates the size of the write + * operation guaranteed to be written atomically to the NVM across + * all namespaces with any supported namespace format during a + * power fail or error condition. This field is specified in + * logical blocks and is a 0’s based value. + * @icsvscc: NVM Vendor Specific Command Configuration, see + * &enum nvme_id_ctrl_nvscc. + * @nwpc: Namespace Write Protection Capabilities, see + * &enum nvme_id_ctrl_nwpc. + * @acwu: Atomic Compare & Write Unit indicates the size of the write + * operation guaranteed to be written atomically to the NVM across + * all namespaces with any supported namespace format for a Compare + * and Write fused operation. This field is specified in logical + * blocks and is a 0’s based value. + * @ocfs: Optional Copy Formats Supported, each bit n means controller + * supports Copy Format n. + * @sgls: SGL Support, see &enum nvme_id_ctrl_sgls + * @mnan: Maximum Number of Allowed Namespaces indicates the maximum + * number of namespaces supported by the NVM subsystem. + * @maxdna: Maximum Domain Namespace Attachments indicates the maximum + * of the sum of the numver of namespaces attached to each I/O + * controller in the Domain. + * @maxcna: Maximum I/O Controller Namespace Attachments indicates the + * maximum number of namespaces that are allowed to be attached to + * this I/O controller. + * @rsvd564: Reserved + * @subnqn: NVM Subsystem NVMe Qualified Name, UTF-8 null terminated string + * @rsvd1024: Reserved + * @ioccsz: I/O Queue Command Capsule Supported Size, defines the maximum + * I/O command capsule size in 16 byte units. + * @iorcsz: I/O Queue Response Capsule Supported Size, defines the maximum + * I/O response capsule size in 16 byte units. + * @icdoff: In Capsule Data Offset, defines the offset where data starts + * within a capsule. This value is applicable to I/O Queues only. + * @fcatt: Fabrics Controller Attributes, see &enum nvme_id_ctrl_fcatt. + * @msdbd: Maximum SGL Data Block Descriptors indicates the maximum + * number of SGL Data Block or Keyed SGL Data Block descriptors + * that a host is allowed to place in a capsule. A value of 0h + * indicates no limit. + * @ofcs: Optional Fabric Commands Support, see &enum nvme_id_ctrl_ofcs. + * @dctype: Discovery Controller Type (DCTYPE). This field indicates what + * type of Discovery controller the controller is (see enum + * nvme_id_ctrl_dctype) + * @rsvd1807: Reserved + * @psd: Power State Descriptors, see &struct nvme_id_psd. + * @vs: Vendor Specific + */ +struct nvme_id_ctrl { + __le16 vid; + __le16 ssvid; + char sn[20]; + char mn[40]; + char fr[8]; + __u8 rab; + __u8 ieee[3]; + __u8 cmic; + __u8 mdts; + __le16 cntlid; + __le32 ver; + __le32 rtd3r; + __le32 rtd3e; + __le32 oaes; + __le32 ctratt; + __le16 rrls; + __u8 rsvd102[9]; + __u8 cntrltype; + __u8 fguid[16]; + __le16 crdt1; + __le16 crdt2; + __le16 crdt3; + __u8 rsvd134[119]; + __u8 nvmsr; + __u8 vwci; + __u8 mec; + __le16 oacs; + __u8 acl; + __u8 aerl; + __u8 frmw; + __u8 lpa; + __u8 elpe; + __u8 npss; + __u8 avscc; + __u8 apsta; + __le16 wctemp; + __le16 cctemp; + __le16 mtfa; + __le32 hmpre; + __le32 hmmin; + __u8 tnvmcap[16]; + __u8 unvmcap[16]; + __le32 rpmbs; + __le16 edstt; + __u8 dsto; + __u8 fwug; + __le16 kas; + __le16 hctma; + __le16 mntmt; + __le16 mxtmt; + __le32 sanicap; + __le32 hmminds; + __le16 hmmaxd; + __le16 nsetidmax; + __le16 endgidmax; + __u8 anatt; + __u8 anacap; + __le32 anagrpmax; + __le32 nanagrpid; + __le32 pels; + __le16 domainid; + __u8 rsvd358[10]; + __u8 megcap[16]; + __u8 rsvd384[128]; + __u8 sqes; + __u8 cqes; + __le16 maxcmd; + __le32 nn; + __le16 oncs; + __le16 fuses; + __u8 fna; + __u8 vwc; + __le16 awun; + __le16 awupf; + __u8 icsvscc; + __u8 nwpc; + __le16 acwu; + __le16 ocfs; + __le32 sgls; + __le32 mnan; + __u8 maxdna[16]; + __le32 maxcna; + __u8 rsvd564[204]; + char subnqn[NVME_NQN_LENGTH]; + __u8 rsvd1024[768]; + + /* Fabrics Only */ + __le32 ioccsz; + __le32 iorcsz; + __le16 icdoff; + __u8 fcatt; + __u8 msdbd; + __le16 ofcs; + __u8 dctype; + __u8 rsvd1807[241]; + + struct nvme_id_psd psd[32]; + __u8 vs[1024]; +}; + +/** + * enum nvme_id_ctrl_cmic - Controller Multipath IO and Namespace Sharing + * Capabilities of the controller and NVM subsystem. + * @NVME_CTRL_CMIC_MULTI_PORT: If set, then the NVM subsystem may contain + * more than one NVM subsystem port, otherwise + * the NVM subsystem contains only a single + * NVM subsystem port. + * @NVME_CTRL_CMIC_MULTI_CTRL: If set, then the NVM subsystem may contain + * two or more controllers, otherwise the + * NVM subsystem contains only a single + * controller. An NVM subsystem that contains + * multiple controllers may be used by + * multiple hosts, or may provide multiple + * paths for a single host. + * @NVME_CTRL_CMIC_MULTI_SRIOV: If set, then the controller is associated + * with an SR-IOV Virtual Function, otherwise + * it is associated with a PCI Function + * or a Fabrics connection. + * @NVME_CTRL_CMIC_MULTI_ANA_REPORTING: If set, then the NVM subsystem supports + * Asymmetric Namespace Access Reporting. + */ +enum nvme_id_ctrl_cmic { + NVME_CTRL_CMIC_MULTI_PORT = 1 << 0, + NVME_CTRL_CMIC_MULTI_CTRL = 1 << 1, + NVME_CTRL_CMIC_MULTI_SRIOV = 1 << 2, + NVME_CTRL_CMIC_MULTI_ANA_REPORTING = 1 << 3, +}; + +/** + * enum nvme_id_ctrl_oaes - Optional Asynchronous Events Supported + * @NVME_CTRL_OAES_NA: Namespace Attribute Notices event supported + * @NVME_CTRL_OAES_FA: Firmware Activation Notices event supported + * @NVME_CTRL_OAES_ANA: ANA Change Notices supported + * @NVME_CTRL_OAES_PLEA: Predictable Latency Event Aggregate Log + * Change Notices event supported + * @NVME_CTRL_OAES_LBAS: LBA Status Information Notices event supported + * @NVME_CTRL_OAES_EGE: Endurance Group Events Aggregate Log Change + * Notices event supported + * @NVME_CTRL_OAES_NS: Normal NVM Subsystem Shutdown event supported + * @NVME_CTRL_OAES_ZD: Zone Descriptor Change Notifications supported + * @NVME_CTRL_OAES_DL: Discover Log Page Change Notifications supported + */ +enum nvme_id_ctrl_oaes { + NVME_CTRL_OAES_NA = 1 << 8, + NVME_CTRL_OAES_FA = 1 << 9, + NVME_CTRL_OAES_ANA = 1 << 11, + NVME_CTRL_OAES_PLEA = 1 << 12, + NVME_CTRL_OAES_LBAS = 1 << 13, + NVME_CTRL_OAES_EGE = 1 << 14, + NVME_CTRL_OAES_NS = 1 << 15, + NVME_CTRL_OAES_ZD = 1 << 27, + NVME_CTRL_OAES_DL = 1 << 31, +}; + +/** + * enum nvme_id_ctrl_ctratt - Controller attributes + * @NVME_CTRL_CTRATT_128_ID: 128-bit Host Identifier supported + * @NVME_CTRL_CTRATT_NON_OP_PSP: Non-Operational Poser State Permissive Mode + * supported + * @NVME_CTRL_CTRATT_NVM_SETS: NVM Sets supported + * @NVME_CTRL_CTRATT_READ_RECV_LVLS: Read Recovery Levels supported + * @NVME_CTRL_CTRATT_ENDURANCE_GROUPS: Endurance Groups supported + * @NVME_CTRL_CTRATT_PREDICTABLE_LAT: Predictable Latency Mode supported + * @NVME_CTRL_CTRATT_TBKAS: Traffic Based Keep Alive Support + * @NVME_CTRL_CTRATT_NAMESPACE_GRANULARITY: Namespace Granularity reporting + * supported + * @NVME_CTRL_CTRATT_SQ_ASSOCIATIONS: SQ Associations supported + * @NVME_CTRL_CTRATT_UUID_LIST: UUID List reporting supported + * @NVME_CTRL_CTRATT_MDS: Multi-Domain Subsystem supported + * @NVME_CTRL_CTRATT_FIXED_CAP: Fixed Capacity Management supported + * @NVME_CTRL_CTRATT_VARIABLE_CAP: Variable Capacity Managment supported + * @NVME_CTRL_CTRATT_DEL_ENDURANCE_GROUPS: Delete Endurance Groups supported + * @NVME_CTRL_CTRATT_DEL_NVM_SETS: Delete NVM Sets supported + * @NVME_CTRL_CTRATT_ELBAS: Extended LBA Formats supported + */ +enum nvme_id_ctrl_ctratt { + NVME_CTRL_CTRATT_128_ID = 1 << 0, + NVME_CTRL_CTRATT_NON_OP_PSP = 1 << 1, + NVME_CTRL_CTRATT_NVM_SETS = 1 << 2, + NVME_CTRL_CTRATT_READ_RECV_LVLS = 1 << 3, + NVME_CTRL_CTRATT_ENDURANCE_GROUPS = 1 << 4, + NVME_CTRL_CTRATT_PREDICTABLE_LAT = 1 << 5, + NVME_CTRL_CTRATT_TBKAS = 1 << 6, + NVME_CTRL_CTRATT_NAMESPACE_GRANULARITY = 1 << 7, + NVME_CTRL_CTRATT_SQ_ASSOCIATIONS = 1 << 8, + NVME_CTRL_CTRATT_UUID_LIST = 1 << 9, + NVME_CTRL_CTRATT_MDS = 1 << 10, + NVME_CTRL_CTRATT_FIXED_CAP = 1 << 11, + NVME_CTRL_CTRATT_VARIABLE_CAP = 1 << 12, + NVME_CTRL_CTRATT_DEL_ENDURANCE_GROUPS = 1 << 13, + NVME_CTRL_CTRATT_DEL_NVM_SETS = 1 << 14, + NVME_CTRL_CTRATT_ELBAS = 1 << 15, +}; + +/** + * enum nvme_id_ctrl_cntrltype - Controller types + * @NVME_CTRL_CNTRLTYPE_IO: NVM I/O controller + * @NVME_CTRL_CNTRLTYPE_DISCOVERY: Discovery controller + * @NVME_CTRL_CNTRLTYPE_ADMIN: Admin controller + */ +enum nvme_id_ctrl_cntrltype { + NVME_CTRL_CNTRLTYPE_IO = 1, + NVME_CTRL_CNTRLTYPE_DISCOVERY = 2, + NVME_CTRL_CNTRLTYPE_ADMIN = 3, +}; + +/** + * enum nvme_id_ctrl_dctype - Discovery Controller types + * @NVME_CTRL_DCTYPE_NOT_REPORTED: Not reported (I/O, Admin, and pre-TP8010) + * @NVME_CTRL_DCTYPE_DDC: Direct Discovery controller + * @NVME_CTRL_DCTYPE_CDC: Central Discovery controller + */ +enum nvme_id_ctrl_dctype { + NVME_CTRL_DCTYPE_NOT_REPORTED = 0, + NVME_CTRL_DCTYPE_DDC = 1, + NVME_CTRL_DCTYPE_CDC = 2, +}; + +/** + * enum nvme_id_ctrl_nvmsr - This field reports information associated with the + * NVM Subsystem, see &struct nvme_id_ctrl.nvmsr. + * @NVME_CTRL_NVMSR_NVMESD: If set, then the NVM Subsystem is part of an NVMe + * Storage Device; if cleared, then the NVM Subsystem + * is not part of an NVMe Storage Device. + * @NVME_CTRL_NVMSR_NVMEE: If set’, then the NVM Subsystem is part of an NVMe + * Enclosure; if cleared, then the NVM Subsystem is + * not part of an NVMe Enclosure. + */ +enum nvme_id_ctrl_nvmsr { + NVME_CTRL_NVMSR_NVMESD = 1 << 0, + NVME_CTRL_NVMSR_NVMEE = 1 << 1, +}; + +/** + * enum nvme_id_ctrl_vwci - This field indicates information about remaining + * number of times that VPD contents are able to be + * updated using the VPD Write command, see &struct + * nvme_id_ctrl.vwci. + * @NVME_CTRL_VWCI_VWCR: Mask to get value of VPD Write Cycles Remaining. If + * the VPD Write Cycle Remaining Valid bit is set, then + * this field contains a value indicating the remaining + * number of times that VPD contents are able to be + * updated using the VPD Write command. If this field is + * set to 7Fh, then the remaining number of times that + * VPD contents are able to be updated using the VPD + * Write command is greater than or equal to 7Fh. + * @NVME_CTRL_VWCI_VWCRV: VPD Write Cycle Remaining Valid. If this bit is set, + * then the VPD Write Cycle Remaining field is valid. If + * this bit is cleared, then the VPD Write Cycles + * Remaining field is invalid and cleared to 0h. + */ +enum nvme_id_ctrl_vwci { + NVME_CTRL_VWCI_VWCR = 0x7f << 0, + NVME_CTRL_VWCI_VWCRV = 1 << 7, +}; + +/** + * enum nvme_id_ctrl_mec - Flags indicatings the capabilities of the Management + * Endpoint in the Controller, &struct nvme_id_ctrl.mec. + * @NVME_CTRL_MEC_SMBUSME: If set, then the NVM Subsystem contains a Management + * Endpoint on an SMBus/I2C port. + * @NVME_CTRL_MEC_PCIEME: If set, then the NVM Subsystem contains a Management + * Endpoint on a PCIe port. + */ +enum nvme_id_ctrl_mec { + NVME_CTRL_MEC_SMBUSME = 1 << 0, + NVME_CTRL_MEC_PCIEME = 1 << 1, +}; + +/** + * enum nvme_id_ctrl_oacs - Flags indicating the optional Admin commands and + * features supported by the controller, see + * &struct nvme_id_ctrl.oacs. + * @NVME_CTRL_OACS_SECURITY: If set, then the controller supports the + * Security Send and Security Receive commands. + * @NVME_CTRL_OACS_FORMAT: If set then the controller supports the Format + * NVM command. + * @NVME_CTRL_OACS_FW: If set, then the controller supports the + * Firmware Commit and Firmware Image Download commands. + * @NVME_CTRL_OACS_NS_MGMT: If set, then the controller supports the + * Namespace Management capability + * @NVME_CTRL_OACS_SELF_TEST: If set, then the controller supports the Device + * Self-test command. + * @NVME_CTRL_OACS_DIRECTIVES: If set, then the controller supports Directives + * and the Directive Send and Directive Receive + * commands. + * @NVME_CTRL_OACS_NVME_MI: If set, then the controller supports the NVMe-MI + * Send and NVMe-MI Receive commands. + * @NVME_CTRL_OACS_VIRT_MGMT: If set, then the controller supports the + * Virtualization Management command. + * @NVME_CTRL_OACS_DBBUF_CFG: If set, then the controller supports the + * Doorbell Buffer Config command. + * @NVME_CTRL_OACS_LBA_STATUS: If set, then the controller supports the Get LBA + * Status capability. + */ +enum nvme_id_ctrl_oacs { + NVME_CTRL_OACS_SECURITY = 1 << 0, + NVME_CTRL_OACS_FORMAT = 1 << 1, + NVME_CTRL_OACS_FW = 1 << 2, + NVME_CTRL_OACS_NS_MGMT = 1 << 3, + NVME_CTRL_OACS_SELF_TEST = 1 << 4, + NVME_CTRL_OACS_DIRECTIVES = 1 << 5, + NVME_CTRL_OACS_NVME_MI = 1 << 6, + NVME_CTRL_OACS_VIRT_MGMT = 1 << 7, + NVME_CTRL_OACS_DBBUF_CFG = 1 << 8, + NVME_CTRL_OACS_LBA_STATUS = 1 << 9, +}; + +/** + * enum nvme_id_ctrl_frmw - Flags and values indicates capabilities regarding + * firmware updates from &struct nvme_id_ctrl.frmw. + * @NVME_CTRL_FRMW_1ST_RO: If set, the first firmware slot is readonly + * @NVME_CTRL_FRMW_NR_SLOTS: Mask to get the value of the number of + * firmware slots that the controller supports. + * @NVME_CTRL_FRMW_FW_ACT_NO_RESET: If set, the controller supports firmware + * activation without a reset. + */ +enum nvme_id_ctrl_frmw { + NVME_CTRL_FRMW_1ST_RO = 1 << 0, + NVME_CTRL_FRMW_NR_SLOTS = 3 << 1, + NVME_CTRL_FRMW_FW_ACT_NO_RESET = 1 << 4, +}; + +/** + * enum nvme_id_ctrl_lpa - Flags indicating optional attributes for log pages + * that are accessed via the Get Log Page command. + * @NVME_CTRL_LPA_SMART_PER_NS: + * @NVME_CTRL_LPA_CMD_EFFECTS: + * @NVME_CTRL_LPA_EXTENDED: + * @NVME_CTRL_LPA_TELEMETRY: + * @NVME_CTRL_LPA_PERSETENT_EVENT: + */ +enum nvme_id_ctrl_lpa { + NVME_CTRL_LPA_SMART_PER_NS = 1 << 0, + NVME_CTRL_LPA_CMD_EFFECTS = 1 << 1, + NVME_CTRL_LPA_EXTENDED = 1 << 2, + NVME_CTRL_LPA_TELEMETRY = 1 << 3, + NVME_CTRL_LPA_PERSETENT_EVENT = 1 << 4, +}; + +/** + * enum nvme_id_ctrl_avscc - Flags indicating the configuration settings for + * Admin Vendor Specific command handling. + * @NVME_CTRL_AVSCC_AVS: If set, all Admin Vendor Specific Commands use the + * optional vendor specific command format with NDT and + * NDM fields. + */ +enum nvme_id_ctrl_avscc { + NVME_CTRL_AVSCC_AVS = 1 << 0, +}; + +/** + * enum nvme_id_ctrl_apsta - Flags indicating the attributes of the autonomous + * power state transition feature. + * @NVME_CTRL_APSTA_APST: If set, then the controller supports autonomous power + * state transitions. + */ +enum nvme_id_ctrl_apsta { + NVME_CTRL_APSTA_APST = 1 << 0, +}; + +/** + * enum nvme_id_ctrl_rpmbs - This field indicates if the controller supports + * one or more Replay Protected Memory Blocks, from + * &struct nvme_id_ctrl.rpmbs. + * @NVME_CTRL_RPMBS_NR_UNITS: Mask to get the value of the Number of RPMB Units + * @NVME_CTRL_RPMBS_AUTH_METHOD: Mask to get the value of the Authentication Method + * @NVME_CTRL_RPMBS_TOTAL_SIZE: Mask to get the value of Total Size + * @NVME_CTRL_RPMBS_ACCESS_SIZE: Mask to get the value of Access Size + */ +enum nvme_id_ctrl_rpmbs { + NVME_CTRL_RPMBS_NR_UNITS = 7 << 0, + NVME_CTRL_RPMBS_AUTH_METHOD = 7 << 3, + NVME_CTRL_RPMBS_TOTAL_SIZE = 0xff << 16, + NVME_CTRL_RPMBS_ACCESS_SIZE = 0xff << 24, +}; + +/** + * enum nvme_id_ctrl_dsto - Flags indicating the optional Device Self-test + * command or operation behaviors supported by the + * controller or NVM subsystem. + * @NVME_CTRL_DSTO_ONE_DST: If set, then the NVM subsystem supports only one + * device self-test operation in progress at a time. + */ +enum nvme_id_ctrl_dsto { + NVME_CTRL_DSTO_ONE_DST = 1 << 0, +}; + +/** + * enum nvme_id_ctrl_hctm - Flags indicate the attributes of the host + * controlled thermal management feature + * @NVME_CTRL_HCTMA_HCTM: then the controller supports host controlled thermal + * management, and the Set Features command and Get + * Features command with the Feature Identifier field + * set to %NVME_FEAT_FID_HCTM. + */ +enum nvme_id_ctrl_hctm { + NVME_CTRL_HCTMA_HCTM = 1 << 0, +}; + +/** + * enum nvme_id_ctrl_sanicap - Indicates attributes for sanitize operations. + * @NVME_CTRL_SANICAP_CES: Crypto Erase Support. If set, then the + * controller supports the Crypto Erase sanitize operation. + * @NVME_CTRL_SANICAP_BES: Block Erase Support. If set, then the controller + * supports the Block Erase sanitize operation. + * @NVME_CTRL_SANICAP_OWS: Overwrite Support. If set, then the controller + * supports the Overwrite sanitize operation. + * @NVME_CTRL_SANICAP_NDI: No-Deallocate Inhibited. If set and the No- + * Deallocate Response Mode bit is set, then the + * controller deallocates after the sanitize + * operation even if the No-Deallocate After + * Sanitize bit is set in a Sanitize command. + * @NVME_CTRL_SANICAP_NODMMAS: No-Deallocate Modifies Media After Sanitize, + * mask to extract value. + */ +enum nvme_id_ctrl_sanicap { + NVME_CTRL_SANICAP_CES = 1 << 0, + NVME_CTRL_SANICAP_BES = 1 << 1, + NVME_CTRL_SANICAP_OWS = 1 << 2, + NVME_CTRL_SANICAP_NDI = 1 << 29, + NVME_CTRL_SANICAP_NODMMAS = 3 << 30, +}; + +/** + * enum nvme_id_ctrl_anacap - This field indicates the capabilities associated + * with Asymmetric Namespace Access Reporting. + * @NVME_CTRL_ANACAP_OPT: If set, then the controller is able to + * report ANA Optimized state. + * @NVME_CTRL_ANACAP_NON_OPT: If set, then the controller is able to + * report ANA Non-Optimized state. + * @NVME_CTRL_ANACAP_INACCESSIBLE: If set, then the controller is able to + * report ANA Inaccessible state. + * @NVME_CTRL_ANACAP_PERSISTENT_LOSS: If set, then the controller is able to + * report ANA Persistent Loss state. + * @NVME_CTRL_ANACAP_CHANGE: If set, then the controller is able to + * report ANA Change state. + * @NVME_CTRL_ANACAP_GRPID_NO_CHG: If set, then the ANAGRPID field in the + * Identify Namespace data structure + * (&struct nvme_id_ns.anagrpid), does not + * change while the namespace is attached to + * any controller. + * @NVME_CTRL_ANACAP_GRPID_MGMT: If set, then the controller supports a + * non-zero value in the ANAGRPID field of + * the Namespace Management command. + */ +enum nvme_id_ctrl_anacap { + NVME_CTRL_ANACAP_OPT = 1 << 0, + NVME_CTRL_ANACAP_NON_OPT = 1 << 1, + NVME_CTRL_ANACAP_INACCESSIBLE = 1 << 2, + NVME_CTRL_ANACAP_PERSISTENT_LOSS = 1 << 3, + NVME_CTRL_ANACAP_CHANGE = 1 << 4, + NVME_CTRL_ANACAP_GRPID_NO_CHG = 1 << 6, + NVME_CTRL_ANACAP_GRPID_MGMT = 1 << 7, +}; + +/** + * enum nvme_id_ctrl_sqes - Defines the required and maximum Submission Queue + * entry size when using the NVM Command Set. + * @NVME_CTRL_SQES_MIN: Mask to get the value of the required Submission Queue + * Entry size when using the NVM Command Set. + * @NVME_CTRL_SQES_MAX: Mask to get the value of the maximum Submission Queue + * entry size when using the NVM Command Set. + */ +enum nvme_id_ctrl_sqes { + NVME_CTRL_SQES_MIN = 0xf << 0, + NVME_CTRL_SQES_MAX = 0xf << 4, +}; + +/** + * enum nvme_id_ctrl_cqes - Defines the required and maximum Completion Queue + * entry size when using the NVM Command Set. + * @NVME_CTRL_CQES_MIN: Mask to get the value of the required Completion Queue + * Entry size when using the NVM Command Set. + * @NVME_CTRL_CQES_MAX: Mask to get the value of the maximum Completion Queue + * entry size when using the NVM Command Set. + */ +enum nvme_id_ctrl_cqes { + NVME_CTRL_CQES_MIN = 0xf << 0, + NVME_CTRL_CQES_MAX = 0xf << 4, +}; + +/** + * enum nvme_id_ctrl_oncs - This field indicates the optional NVM commands and + * features supported by the controller. + * @NVME_CTRL_ONCS_COMPARE: If set, then the controller supports + * the Compare command. + * @NVME_CTRL_ONCS_WRITE_UNCORRECTABLE: If set, then the controller supports + * the Write Uncorrectable command. + * @NVME_CTRL_ONCS_DSM: If set, then the controller supports + * the Dataset Management command. + * @NVME_CTRL_ONCS_WRITE_ZEROES: If set, then the controller supports + * the Write Zeroes command. + * @NVME_CTRL_ONCS_SAVE_FEATURES: If set, then the controller supports + * the Save field set to a non-zero value + * in the Set Features command and the + * Select field set to a non-zero value in + * the Get Features command. + * @NVME_CTRL_ONCS_RESERVATIONS: If set, then the controller supports + * reservations. + * @NVME_CTRL_ONCS_TIMESTAMP: If set, then the controller supports + * the Timestamp feature. + * @NVME_CTRL_ONCS_VERIFY: If set, then the controller supports + * the Verify command. + */ +enum nvme_id_ctrl_oncs { + NVME_CTRL_ONCS_COMPARE = 1 << 0, + NVME_CTRL_ONCS_WRITE_UNCORRECTABLE = 1 << 1, + NVME_CTRL_ONCS_DSM = 1 << 2, + NVME_CTRL_ONCS_WRITE_ZEROES = 1 << 3, + NVME_CTRL_ONCS_SAVE_FEATURES = 1 << 4, + NVME_CTRL_ONCS_RESERVATIONS = 1 << 5, + NVME_CTRL_ONCS_TIMESTAMP = 1 << 6, + NVME_CTRL_ONCS_VERIFY = 1 << 7, +}; + +/** + * enum nvme_id_ctrl_fuses - This field indicates the fused operations that the + * controller supports. + * @NVME_CTRL_FUSES_COMPARE_AND_WRITE: If set, then the controller supports the + * Compare and Write fused operation. + */ +enum nvme_id_ctrl_fuses { + NVME_CTRL_FUSES_COMPARE_AND_WRITE = 1 << 0, +}; + +/** + * enum nvme_id_ctrl_fna - This field indicates attributes for the Format NVM + * command. + * @NVME_CTRL_FNA_FMT_ALL_NAMESPACES: If set, then all namespaces in an NVM + * subsystem shall be configured with the + * same attributes and a format (excluding + * secure erase) of any namespace results in + * a format of all namespaces in an NVM + * subsystem. If cleared, then the + * controller supports format on a per + * namespace basis. + * @NVME_CTRL_FNA_SEC_ALL_NAMESPACES: If set, then any secure erase performed + * as part of a format operation results in + * a secure erase of all namespaces in the + * NVM subsystem. If cleared, then any + * secure erase performed as part of a + * format results in a secure erase of the + * particular namespace specified. + * @NVME_CTRL_FNA_CRYPTO_ERASE: If set, then cryptographic erase is + * supported. If cleared, then cryptographic + * erase is not supported. + */ +enum nvme_id_ctrl_fna { + NVME_CTRL_FNA_FMT_ALL_NAMESPACES = 1 << 0, + NVME_CTRL_FNA_SEC_ALL_NAMESPACES = 1 << 1, + NVME_CTRL_FNA_CRYPTO_ERASE = 1 << 2, +}; + +/** + * enum nvme_id_ctrl_vwc - + * @NVME_CTRL_VWC_PRESENT: If set, indicates a volatile write cache is present. + * If a volatile write cache is present, then the host + * controls whether the volatile write cache is enabled + * with a Set Features command specifying the value + * %NVME_FEAT_FID_VOLATILE_WC. + * @NVME_CTRL_VWC_FLUSH: Mask to get the value of the flush command behavior. + */ +enum nvme_id_ctrl_vwc { + NVME_CTRL_VWC_PRESENT = 1 << 0, + NVME_CTRL_VWC_FLUSH = 3 << 1, +}; + +/** + * enum nvme_id_ctrl_nvscc - This field indicates the configuration settings + * for NVM Vendor Specific command handling. + * @NVME_CTRL_NVSCC_FMT: If set, all NVM Vendor Specific Commands use the + * format format with NDT and NDM fields. + */ +enum nvme_id_ctrl_nvscc { + NVME_CTRL_NVSCC_FMT = 1 << 0, +}; + +/** + * enum nvme_id_ctrl_nwpc - This field indicates the optional namespace write + * protection capabilities supported by the + * controller. + * @NVME_CTRL_NWPC_WRITE_PROTECT: If set, then the controller shall + * support the No Write Protect and + * Write Protect namespace write + * protection states and may support + * the Write Protect Until Power + * Cycle state and Permanent Write + * Protect namespace write + * protection states. + * @NVME_CTRL_NWPC_WRITE_PROTECT_POWER_CYCLE: If set, then the controller + * supports the Write Protect Until + * Power Cycle state. + * @NVME_CTRL_NWPC_WRITE_PROTECT_PERMANENT: If set, then the controller + * supports the Permanent Write + * Protect state. + */ +enum nvme_id_ctrl_nwpc { + NVME_CTRL_NWPC_WRITE_PROTECT = 1 << 0, + NVME_CTRL_NWPC_WRITE_PROTECT_POWER_CYCLE= 1 << 1, + NVME_CTRL_NWPC_WRITE_PROTECT_PERMANENT = 1 << 2, +}; + +/** + * enum nvme_id_ctrl_sgls - This field indicates if SGLs are supported for the + * NVM Command Set and the particular SGL types supported. + * @NVME_CTRL_SGLS_SUPPORTED: + * @NVME_CTRL_SGLS_KEYED: + * @NVME_CTRL_SGLS_BIT_BUCKET: + * @NVME_CTRL_SGLS_MPTR_BYTE_ALIGNED: + * @NVME_CTRL_SGLS_OVERSIZE: + * @NVME_CTRL_SGLS_MPTR_SGL: + * @NVME_CTRL_SGLS_OFFSET: + * @NVME_CTRL_SGLS_TPORT: + */ +enum nvme_id_ctrl_sgls { + NVME_CTRL_SGLS_SUPPORTED = 3 << 0, + NVME_CTRL_SGLS_KEYED = 1 << 2, + NVME_CTRL_SGLS_BIT_BUCKET = 1 << 16, + NVME_CTRL_SGLS_MPTR_BYTE_ALIGNED = 1 << 17, + NVME_CTRL_SGLS_OVERSIZE = 1 << 18, + NVME_CTRL_SGLS_MPTR_SGL = 1 << 19, + NVME_CTRL_SGLS_OFFSET = 1 << 20, + NVME_CTRL_SGLS_TPORT = 1 << 21, +}; + +/** + * enum nvme_id_ctrl_fcatt - This field indicates attributes of the controller + * that are specific to NVMe over Fabrics. + * @NVME_CTRL_FCATT_DYNAMIC: If cleared, then the NVM subsystem uses a dynamic + * controller model. If set, then the NVM subsystem + * uses a static controller model. + */ +enum nvme_id_ctrl_fcatt { + NVME_CTRL_FCATT_DYNAMIC = 1 << 0, +}; + +/** + * enum nvme_id_ctrl_ofcs - Indicate whether the controller supports optional + * fabric commands. + * @NVME_CTRL_OFCS_DISCONNECT: If set, then the controller supports the + * Disconnect command and deletion of individual + * I/O Queues. + */ +enum nvme_id_ctrl_ofcs { + NVME_CTRL_OFCS_DISCONNECT = 1 << 0, +}; + +/** + * struct nvme_lbaf - LBA Format Data Structure + * @ms: Metadata Size indicates the number of metadata bytes provided per LBA + * based on the LBA Data Size indicated. + * @ds: LBA Data Size indicates the LBA data size supported, reported as a + * power of two. + * @rp: Relative Performance, see &enum nvme_lbaf_rp. + */ +struct nvme_lbaf { + __le16 ms; + __u8 ds; + __u8 rp; +}; + +/** + * enum nvme_lbaf_rp - This field indicates the relative performance of the LBA + * format indicated relative to other LBA formats supported + * by the controller. + * @NVME_LBAF_RP_BEST: Best performance + * @NVME_LBAF_RP_BETTER: Better performance + * @NVME_LBAF_RP_GOOD: Good performance + * @NVME_LBAF_RP_DEGRADED: Degraded performance + * @NVME_LBAF_RP_MASK: Mask to get the relative performance value from the + * field + */ +enum nvme_lbaf_rp { + NVME_LBAF_RP_BEST = 0, + NVME_LBAF_RP_BETTER = 1, + NVME_LBAF_RP_GOOD = 2, + NVME_LBAF_RP_DEGRADED = 3, + NVME_LBAF_RP_MASK = 3, +}; + +/** + * struct nvme_id_ns - Identify Namespace data structure + * @nsze: Namespace Size indicates the total size of the namespace in + * logical blocks. The number of logical blocks is based on the + * formatted LBA size. + * @ncap: Namespace Capacity indicates the maximum number of logical blocks + * that may be allocated in the namespace at any point in time. The + * number of logical blocks is based on the formatted LBA size. + * @nuse: Namespace Utilization indicates the current number of logical + * blocks allocated in the namespace. This field is smaller than or + * equal to the Namespace Capacity. The number of logical blocks is + * based on the formatted LBA size. + * @nsfeat: Namespace Features, see &enum nvme_id_nsfeat. + * @nlbaf: Number of LBA Formats defines the number of supported LBA data + * size and metadata size combinations supported by the namespace + * and the highest possible index to &struct nvme_id_ns.lbaf. + * @flbas: Formatted LBA Size, see &enum nvme_id_ns_flbas. + * @mc: Metadata Capabilities, see &enum nvme_id_ns_mc. + * @dpc: End-to-end Data Protection Capabilities, see + * &enum nvme_id_ns_dpc. + * @dps: End-to-end Data Protection Type Settings, see + * &enum nvme_id_ns_dps. + * @nmic: Namespace Multi-path I/O and Namespace Sharing Capabilities, see + * &enum nvme_id_ns_nmic. + * @rescap: Reservation Capabilities, see &enum nvme_id_ns_rescap. + * @fpi: Format Progress Indicator, see &enum nvme_nd_ns_fpi. + * @dlfeat: Deallocate Logical Block Features, see &enum nvme_id_ns_dlfeat. + * @nawun: Namespace Atomic Write Unit Normal indicates the + * namespace specific size of the write operation guaranteed to be + * written atomically to the NVM during normal operation. + * @nawupf: Namespace Atomic Write Unit Power Fail indicates the + * namespace specific size of the write operation guaranteed to be + * written atomically to the NVM during a power fail or error + * condition. + * @nacwu: Namespace Atomic Compare & Write Unit indicates the namespace + * specific size of the write operation guaranteed to be written + * atomically to the NVM for a Compare and Write fused command. + * @nabsn: Namespace Atomic Boundary Size Normal indicates the atomic + * boundary size for this namespace for the NAWUN value. This field + * is specified in logical blocks. + * @nabo: Namespace Atomic Boundary Offset indicates the LBA on this + * namespace where the first atomic boundary starts. + * @nabspf: Namespace Atomic Boundary Size Power Fail indicates the atomic + * boundary size for this namespace specific to the Namespace Atomic + * Write Unit Power Fail value. This field is specified in logical + * blocks. + * @noiob: Namespace Optimal I/O Boundary indicates the optimal I/O boundary + * for this namespace. This field is specified in logical blocks. + * The host should construct Read and Write commands that do not + * cross the I/O boundary to achieve optimal performance. + * @nvmcap: NVM Capacity indicates the total size of the NVM allocated to + * this namespace. The value is in bytes. + * @npwg: Namespace Preferred Write Granularity indicates the smallest + * recommended write granularity in logical blocks for this + * namespace. This is a 0's based value. + * @npwa: Namespace Preferred Write Alignment indicates the recommended + * write alignment in logical blocks for this namespace. This is a + * 0's based value. + * @npdg: Namespace Preferred Deallocate Granularity indicates the + * recommended granularity in logical blocks for the Dataset + * Management command with the Attribute - Deallocate bit. + * @npda: Namespace Preferred Deallocate Alignment indicates the + * recommended alignment in logical blocks for the Dataset + * Management command with the Attribute - Deallocate bit + * @nows: Namespace Optimal Write Size indicates the size in logical blocks + * for optimal write performance for this namespace. This is a 0's + * based value. + * @mssrl: Maximum Single Source Range Length indicates the maximum number + * of logical blocks that may be specified in each valid Source Range + * field of a Copy command. + * @mcl: Maximum Copy Length indicates the maximum number of logical + * blocks that may be specified in a Copy command. + * @msrc: Maximum Source Range Count indicates the maximum number of Source + * Range entries that may be used to specify source data in a Copy + * command. This is a 0’s based value. + * @rsvd81: Reserved + * @nulbaf: Number of Unique Capability LBA Formats defines the number of + * supported user data size and metadata size combinations supported + * by the namespace that may not share the same capabilities. LBA + * formats shall be allocated in order and packed sequentially. + * @rsvd83: Reserved + * @anagrpid: ANA Group Identifier indicates the ANA Group Identifier of the + * ANA group of which the namespace is a member. + * @rsvd96: Reserved + * @nsattr: Namespace Attributes, see &enum nvme_id_ns_attr. + * @nvmsetid: NVM Set Identifier indicates the NVM Set with which this + * namespace is associated. + * @endgid: Endurance Group Identifier indicates the Endurance Group with + * which this namespace is associated. + * @nguid: Namespace Globally Unique Identifier contains a 128-bit value + * that is globally unique and assigned to the namespace when the + * namespace is created. This field remains fixed throughout the + * life of the namespace and is preserved across namespace and + * controller operations + * @eui64: IEEE Extended Unique Identifier contains a 64-bit IEEE Extended + * Unique Identifier (EUI-64) that is globally unique and assigned + * to the namespace when the namespace is created. This field + * remains fixed throughout the life of the namespace and is + * preserved across namespace and controller operations + * @lbaf: LBA Format, see &struct nvme_lbaf. + * @lbstm: Logical Block Storage Tag Mask for end-to-end protection + * @vs: Vendor Specific + */ +struct nvme_id_ns { + __le64 nsze; + __le64 ncap; + __le64 nuse; + __u8 nsfeat; + __u8 nlbaf; + __u8 flbas; + __u8 mc; + __u8 dpc; + __u8 dps; + __u8 nmic; + __u8 rescap; + __u8 fpi; + __u8 dlfeat; + __le16 nawun; + __le16 nawupf; + __le16 nacwu; + __le16 nabsn; + __le16 nabo; + __le16 nabspf; + __le16 noiob; + __u8 nvmcap[16]; + __le16 npwg; + __le16 npwa; + __le16 npdg; + __le16 npda; + __le16 nows; + __le16 mssrl; + __le32 mcl; + __u8 msrc; + __u8 rsvd81; + __u8 nulbaf; + __u8 rsvd83[9]; + __le32 anagrpid; + __u8 rsvd96[3]; + __u8 nsattr; + __le16 nvmsetid; + __le16 endgid; + __u8 nguid[16]; + __u8 eui64[8]; + struct nvme_lbaf lbaf[64]; + __le64 lbstm; + __u8 vs[3704]; +}; + +/** + * enum nvme_id_nsfeat - This field defines features of the namespace. + * @NVME_NS_FEAT_THIN: If set, indicates that the namespace supports thin + * provisioning. Specifically, the Namespace Capacity + * reported may be less than the Namespace Size. + * @NVME_NS_FEAT_NATOMIC: If set, indicates that the fields NAWUN, NAWUPF, and + * NACWU are defined for this namespace and should be + * used by the host for this namespace instead of the + * AWUN, AWUPF, and ACWU fields in the Identify + * Controller data structure. + * @NVME_NS_FEAT_DULBE: If set, indicates that the controller supports the + * Deallocated or Unwritten Logical Block error for + * this namespace. + * @NVME_NS_FEAT_ID_REUSE: If set, indicates that the value in the NGUID field + * for this namespace, if non- zero, is never reused by + * the controller and that the value in the EUI64 field + * for this namespace, if non-zero, is never reused by + * the controller. + * @NVME_NS_FEAT_IO_OPT: If set, indicates that the fields NPWG, NPWA, NPDG, + * NPDA, and NOWS are defined for this namespace and + * should be used by the host for I/O optimization + */ +enum nvme_id_nsfeat { + NVME_NS_FEAT_THIN = 1 << 0, + NVME_NS_FEAT_NATOMIC = 1 << 1, + NVME_NS_FEAT_DULBE = 1 << 2, + NVME_NS_FEAT_ID_REUSE = 1 << 3, + NVME_NS_FEAT_IO_OPT = 1 << 4, +}; + +/** + * enum nvme_id_ns_flbas - This field indicates the LBA data size & metadata + * size combination that the namespace has been + * formatted with + * @NVME_NS_FLBAS_LOWER_MASK: Mask to get the index of one of the supported + * LBA Formats's least significant + * 4bits indicated in + * :c:type:`struct nvme_id_ns <nvme_id_ns>`.lbaf. + * @NVME_NS_FLBAS_META_EXT: Applicable only if format contains metadata. If + * this bit is set, indicates that the metadata is + * transferred at the end of the data LBA, creating an + * extended data LBA. If cleared, indicates that all + * of the metadata for a command is transferred as a + * separate contiguous buffer of data. + * @NVME_NS_FLBAS_HIGHER_MASK: Mask to get the index of one of + * the supported LBA Formats's most significant + * 2bits indicated in + * :c:type:`struct nvme_id_ns <nvme_id_ns>`.lbaf. + */ +enum nvme_id_ns_flbas { + NVME_NS_FLBAS_LOWER_MASK = 15 << 0, + NVME_NS_FLBAS_META_EXT = 1 << 4, + NVME_NS_FLBAS_HIGHER_MASK = 3 << 5, +}; + +/** + * enum nvme_id_ns_mc - This field indicates the capabilities for metadata. + * @NVME_NS_MC_EXTENDED: If set, indicates the namespace supports the metadata + * being transferred as part of a separate buffer that is + * specified in the Metadata Pointer. + * @NVME_NS_MC_SEPARATE: If set, indicates that the namespace supports the + * metadata being transferred as part of an extended data LBA. + */ +enum nvme_id_ns_mc { + NVME_NS_MC_EXTENDED = 1 << 0, + NVME_NS_MC_SEPARATE = 1 << 1, +}; + +/** + * enum nvme_id_ns_dpc - This field indicates the capabilities for the + * end-to-end data protection feature. + * @NVME_NS_DPC_PI_TYPE1: If set, indicates that the namespace supports + * Protection Information Type 1. + * @NVME_NS_DPC_PI_TYPE2: If set, indicates that the namespace supports + * Protection Information Type 2. + * @NVME_NS_DPC_PI_TYPE3: If set, indicates that the namespace supports + * Protection Information Type 3. + * @NVME_NS_DPC_PI_FIRST: If set, indicates that the namespace supports + * protection information transferred as the first eight + * bytes of metadata. + * @NVME_NS_DPC_PI_LAST: If set, indicates that the namespace supports + * protection information transferred as the last eight + * bytes of metadata. + */ +enum nvme_id_ns_dpc { + NVME_NS_DPC_PI_TYPE1 = 1 << 0, + NVME_NS_DPC_PI_TYPE2 = 1 << 1, + NVME_NS_DPC_PI_TYPE3 = 1 << 2, + NVME_NS_DPC_PI_FIRST = 1 << 3, + NVME_NS_DPC_PI_LAST = 1 << 4, +}; + +/** + * enum nvme_id_ns_dps - This field indicates the Type settings for the + * end-to-end data protection feature. + * @NVME_NS_DPS_PI_NONE: Protection information is not enabled + * @NVME_NS_DPS_PI_TYPE1: Protection information is enabled, Type 1 + * @NVME_NS_DPS_PI_TYPE2: Protection information is enabled, Type 2 + * @NVME_NS_DPS_PI_TYPE3: Protection information is enabled, Type 3 + * @NVME_NS_DPS_PI_MASK: Mask to get the value of the PI type + * @NVME_NS_DPS_PI_FIRST: If set, indicates that the protection information, if + * enabled, is transferred as the first eight bytes of + * metadata. + */ +enum nvme_id_ns_dps { + NVME_NS_DPS_PI_NONE = 0, + NVME_NS_DPS_PI_TYPE1 = 1, + NVME_NS_DPS_PI_TYPE2 = 2, + NVME_NS_DPS_PI_TYPE3 = 3, + NVME_NS_DPS_PI_MASK = 7 << 0, + NVME_NS_DPS_PI_FIRST = 1 << 3, +}; + +/** + * enum nvme_id_ns_nmic - This field specifies multi-path I/O and namespace + * sharing capabilities of the namespace. + * @NVME_NS_NMIC_SHARED: If set, then the namespace may be attached to two or + * more controllers in the NVM subsystem concurrently + */ +enum nvme_id_ns_nmic { + NVME_NS_NMIC_SHARED = 1 << 0, +}; + +/** + * enum nvme_id_ns_rescap - This field indicates the reservation capabilities + * of the namespace. + * @NVME_NS_RESCAP_PTPL: If set, indicates that the namespace supports the + * Persist Through Power Loss capability. + * @NVME_NS_RESCAP_WE: If set, indicates that the namespace supports the + * Write Exclusive reservation type. + * @NVME_NS_RESCAP_EA: If set, indicates that the namespace supports the + * Exclusive Access reservation type. + * @NVME_NS_RESCAP_WERO: If set, indicates that the namespace supports the + * Write Exclusive - Registrants Only reservation type. + * @NVME_NS_RESCAP_EARO: If set, indicates that the namespace supports the + * Exclusive Access - Registrants Only reservation type. + * @NVME_NS_RESCAP_WEAR: If set, indicates that the namespace supports the + * Write Exclusive - All Registrants reservation type. + * @NVME_NS_RESCAP_EAAR: If set, indicates that the namespace supports the + * Exclusive Access - All Registrants reservation type. + * @NVME_NS_RESCAP_IEK_13: If set, indicates that Ignore Existing Key is used + * as defined in revision 1.3 or later of this specification. + */ +enum nvme_id_ns_rescap { + NVME_NS_RESCAP_PTPL = 1 << 0, + NVME_NS_RESCAP_WE = 1 << 1, + NVME_NS_RESCAP_EA = 1 << 2, + NVME_NS_RESCAP_WERO = 1 << 3, + NVME_NS_RESCAP_EARO = 1 << 4, + NVME_NS_RESCAP_WEAR = 1 << 5, + NVME_NS_RESCAP_EAAR = 1 << 6, + NVME_NS_RESCAP_IEK_13 = 1 << 7, +}; + +/** + * enum nvme_nd_ns_fpi - If a format operation is in progress, this field + * indicates the percentage of the namespace that remains + * to be formatted. + * @NVME_NS_FPI_REMAINING: Mask to get the format percent remaining value + * @NVME_NS_FPI_SUPPORTED: If set, indicates that the namespace supports the + * Format Progress Indicator defined for the field. + */ +enum nvme_nd_ns_fpi { + NVME_NS_FPI_REMAINING = 0x7f << 0, + NVME_NS_FPI_SUPPORTED = 1 << 7, +}; + +/** + * enum nvme_id_ns_dlfeat - This field indicates information about features + * that affect deallocating logical blocks for this + * namespace. + * @NVME_NS_DLFEAT_RB: Mask to get the value of the read behavior + * @NVME_NS_DLFEAT_RB_NR: Read behvaior is not reported + * @NVME_NS_DLFEAT_RB_ALL_0S: A deallocated logical block returns all bytes + * cleared to 0h. + * @NVME_NS_DLFEAT_RB_ALL_FS: A deallocated logical block returns all bytes + * set to FFh. + * @NVME_NS_DLFEAT_WRITE_ZEROES: If set, indicates that the controller supports + * the Deallocate bit in the Write Zeroes command + * for this namespace. + * @NVME_NS_DLFEAT_CRC_GUARD: If set, indicates that the Guard field for + * deallocated logical blocks that contain + * protection information is set to the CRC for + * the value read from the deallocated logical + * block and its metadata + */ +enum nvme_id_ns_dlfeat { + NVME_NS_DLFEAT_RB = 7 << 0, + NVME_NS_DLFEAT_RB_NR = 0, + NVME_NS_DLFEAT_RB_ALL_0S = 1, + NVME_NS_DLFEAT_RB_ALL_FS = 2, + NVME_NS_DLFEAT_WRITE_ZEROES = 1 << 3, + NVME_NS_DLFEAT_CRC_GUARD = 1 << 4, +}; + +/** + * enum nvme_id_ns_attr - Specifies attributes of the namespace. + * @NVME_NS_NSATTR_WRITE_PROTECTED: If set, then the namespace is currently + * write protected and all write access to the + * namespace shall fail. + */ +enum nvme_id_ns_attr { + NVME_NS_NSATTR_WRITE_PROTECTED = 1 << 0 +}; + +/** + * struct nvme_ns_id_desc - + * @nidt: Namespace Identifier Type, see &enum nvme_ns_id_desc_nidt + * @nidl: Namespace Identifier Length contains the length in bytes of the + * &struct nvme_id_ns.nid. + * @rsvd: Reserved + * @nid: Namespace Identifier contains a value that is globally unique and + * assigned to the namespace when the namespace is created. The length + * is defined in &struct nvme_id_ns.nidl. + */ +struct nvme_ns_id_desc { + __u8 nidt; + __u8 nidl; + __le16 rsvd; + __u8 nid[]; +}; + +/** + * enum nvme_ns_id_desc_nidt - Known namespace identifier types + * @NVME_NIDT_EUI64: IEEE Extended Unique Identifier, the NID field contains a + * copy of the EUI64 field in the struct nvme_id_ns.eui64. + * @NVME_NIDT_NGUID: Namespace Globally Unique Identifier, the NID field + * contains a copy of the NGUID field in struct nvme_id_ns.nguid. + * @NVME_NIDT_UUID: The NID field contains a 128-bit Universally Unique + * Identifier (UUID) as specified in RFC 4122. + * @NVME_NIDT_CSI: The NID field contains the command set indentifier. + */ +enum nvme_ns_id_desc_nidt { + NVME_NIDT_EUI64 = 1, + NVME_NIDT_NGUID = 2, + NVME_NIDT_UUID = 3, + NVME_NIDT_CSI = 4, +}; + +enum nvme_ns_id_desc_nidt_lens { + NVME_NIDT_EUI64_LEN = 8, + NVME_NIDT_NGUID_LEN = 16, + NVME_NIDT_UUID_LEN = 16, + NVME_NIDT_CSI_LEN = 1, +}; + +/** + * struct nvme_nvmset_attr - NVM Set Attributes Entry + * @nvmsetid: NVM Set Identifier + * @endgid: Endurance Group Identifier + * @rsvd4: Reserved + * @rr4kt: Random 4 KiB Read Typical indicates the typical + * time to complete a 4 KiB random read in 100 nanosecond units + * when the NVM Set is in a Predictable Latency Mode Deterministic + * Window and there is 1 outstanding command per NVM Set. + * @ows: Optimal Write Size + * @tnvmsetcap: Total NVM Set Capacity + * @unvmsetcap: Unallocated NVM Set Capacity + * @rsvd48: Reserved + */ +struct nvme_nvmset_attr { + __le16 nvmsetid; + __le16 endgid; + __u8 rsvd4[4]; + __le32 rr4kt; + __le32 ows; + __u8 tnvmsetcap[16]; + __u8 unvmsetcap[16]; + __u8 rsvd48[80]; +}; + +/** + * struct nvme_id_nvmset_list - + * @nid: Nvmset id + * @rsvd1: Reserved + * @ent: nvmset id list + */ +struct nvme_id_nvmset_list { + __u8 nid; + __u8 rsvd1[127]; + struct nvme_nvmset_attr ent[NVME_ID_NVMSET_LIST_MAX]; +}; + +/** + * struct nvme_id_independent_id_ns - + * @nsfeat: common namespace features + * @nmic: Namespace Multi-path I/O and Namespace + * Sharing Capabilities + * @rescap: Reservation Capabilities + * @fpi: Format Progress Indicator + * @anagrpid: ANA Group Identifier + * @nsattr: Namespace Attributes + * @rsvd9: reserved + * @nvmsetid: NVM Set Identifier + * @endgid: Endurance Group Identifier + * @nstat: Namespace Status + * @rsvd15: reserved + */ +struct nvme_id_independent_id_ns { + __u8 nsfeat; + __u8 nmic; + __u8 rescap; + __u8 fpi; + __le32 anagrpid; + __u8 nsattr; + __u8 rsvd9; + __le16 nvmsetid; + __le16 endgid; + __u8 nstat; + __u8 rsvd15[4081]; +}; + +/** + * struct nvme_id_ns_granularity_desc - + * @nszegran: Namespace Size Granularity + * @ncapgran: Namespace Capacity Granularity + */ +struct nvme_id_ns_granularity_desc { + __le64 nszegran; + __le64 ncapgran; +}; + +/** + * struct nvme_id_ns_granularity_list - + * @attributes: Namespace Granularity Attributes + * @num_descriptors: Number of Descriptors + * @rsvd5: reserved + * @entry: Namespace Granularity Descriptor + * @rsvd288: reserved + */ +struct nvme_id_ns_granularity_list { + __le32 attributes; + __u8 num_descriptors; + __u8 rsvd5[27]; + struct nvme_id_ns_granularity_desc entry[NVME_ID_ND_DESCRIPTOR_MAX]; + __u8 rsvd288[3808]; +}; + +/** + * struct nvme_id_uuid_list_entry - + * @header: UUID Lists Entry Header + * @rsvd1: reserved + * @uuid: 128-bit Universally Unique Identifier + */ +struct nvme_id_uuid_list_entry { + __u8 header; + __u8 rsvd1[15]; + __u8 uuid[16]; +}; + +/** + * enum nvme_id_uuid - + * @NVME_ID_UUID_HDR_ASSOCIATION_MASK: + * @NVME_ID_UUID_ASSOCIATION_NONE: + * @NVME_ID_UUID_ASSOCIATION_VENDOR: + * @NVME_ID_UUID_ASSOCIATION_SUBSYSTEM_VENDOR: + */ +enum nvme_id_uuid { + NVME_ID_UUID_HDR_ASSOCIATION_MASK = 0x3, + NVME_ID_UUID_ASSOCIATION_NONE = 0, + NVME_ID_UUID_ASSOCIATION_VENDOR = 1, + NVME_ID_UUID_ASSOCIATION_SUBSYSTEM_VENDOR = 2, +}; + +/** + * struct nvme_id_uuid_list - + * @rsvd0: reserved + * @entry: UUID list entry + */ +struct nvme_id_uuid_list { + __u8 rsvd0[32]; + struct nvme_id_uuid_list_entry entry[NVME_ID_UUID_LIST_MAX]; +}; + +/** + * struct nvme_ctrl_list - + * @num: Number of Identifiers + * @identifier: NVM subsystem unique controller identifier + */ +struct nvme_ctrl_list { + __le16 num; + __le16 identifier[NVME_ID_CTRL_LIST_MAX]; +}; + +/** + * struct nvme_ns_list - + * @ns: Namespace Identifier + */ +struct nvme_ns_list { + __le32 ns[NVME_ID_NS_LIST_MAX]; +}; + +/** + * struct nvme_id_ctrl_nvm - + * @vsl: Verify Size Limit + * @wzsl: Write Zeroes Size Limit + * @wusl: Write Uncorrectable Size Limit + * @dmrl: Dataset Management Ranges Limit + * @dmrsl: Dataset Management Range Size Limit + * @dmsl: Dataset Management Size Limit + * @rsvd16: reserved + */ +struct nvme_id_ctrl_nvm { + __u8 vsl; + __u8 wzsl; + __u8 wusl; + __u8 dmrl; + __u32 dmrsl; + __u64 dmsl; + __u8 rsvd16[4080]; +}; + +/** + * struct nvme_nvm_id_ns - + * @lbstm: Logical Block Storage Tag Mask + * @pic: Protection Information Capabilities + * @rsvd9: Reserved + * @elbaf: List of Extended LBA Format Support + * @rsvd268: Reserved + */ +struct nvme_nvm_id_ns { + __le64 lbstm; + __u8 pic; + __u8 rsvd9[3]; + __le32 elbaf[64]; + __u8 rsvd268[3828]; +}; + +/** + * struct nvme_zns_lbafe - + * @zsze: Zone Size + * @zdes: Zone Descriptor Extension Size + * @rsvd9: reserved + */ +struct nvme_zns_lbafe { + __le64 zsze; + __u8 zdes; + __u8 rsvd9[7]; +}; + +/** + * struct nvme_zns_id_ns - Zoned Namespace Command Set Specific + * Identify Namespace Data Structure + * @zoc: Zone Operation Characteristics + * @ozcs: Optional Zoned Command Support + * @mar: Maximum Active Resources + * @mor: Maximum Open Resources + * @rrl: Reset Recommended Limit + * @frl: Finish Recommended Limit + * @rrl1: Reset Recommended Limit 1 + * @rrl2: Reset Recommended Limit 2 + * @rrl3: Reset Recommended Limit 3 + * @frl1: Finish Recommended Limit 1 + * @frl2: Finish Recommended Limit 2 + * @frl3: Finish Recommended Limit 3 + * @numzrwa: Number of ZRWA Resources + * @zrwafg: ZRWA Flush Granularity + * @zrwasz: ZRWA Size + * @zrwacap: ZRWA Capability + * @rsvd53: Reserved + * @lbafe: LBA Format Extension + * @vs: Vendor Specific + */ +struct nvme_zns_id_ns { + __le16 zoc; + __le16 ozcs; + __le32 mar; + __le32 mor; + __le32 rrl; + __le32 frl; + __le32 rrl1; + __le32 rrl2; + __le32 rrl3; + __le32 frl1; + __le32 frl2; + __le32 frl3; + __le32 numzrwa; + __le16 zrwafg; + __le16 zrwasz; + __u8 zrwacap; + __u8 rsvd53[2763]; + struct nvme_zns_lbafe lbafe[64]; + __u8 vs[256]; +}; + +/** + * struct nvme_zns_id_ctrl - + * @zasl: + * @rsvd1: Reserved + */ +struct nvme_zns_id_ctrl { + __u8 zasl; + __u8 rsvd1[4095]; +}; + +/** + * struct nvme_primary_ctrl_cap - + * @cntlid: Controller Identifier + * @portid: Port Identifier + * @crt: Controller Resource Types + * @rsvd5: reserved + * @vqfrt: VQ Resources Flexible Total + * @vqrfa: VQ Resources Flexible Assigned + * @vqrfap: VQ Resources Flexible Allocated to Primary + * @vqprt: VQ Resources Private Total + * @vqfrsm: VQ Resources Flexible Secondary Maximum + * @vqgran: VQ Flexible Resource Preferred Granularity + * @rsvd48: reserved + * @vifrt: VI Resources Flexible Total + * @virfa: VI Resources Flexible Assigned + * @virfap: VI Resources Flexible Allocated to Primary + * @viprt: VI Resources Private Total + * @vifrsm: VI Resources Flexible Secondary Maximum + * @vigran: VI Flexible Resource Preferred Granularity + * @rsvd80: reserved + */ +struct nvme_primary_ctrl_cap { + __le16 cntlid; + __le16 portid; + __u8 crt; + __u8 rsvd5[27]; + __le32 vqfrt; + __le32 vqrfa; + __le16 vqrfap; + __le16 vqprt; + __le16 vqfrsm; + __le16 vqgran; + __u8 rsvd48[16]; + __le32 vifrt; + __le32 virfa; + __le16 virfap; + __le16 viprt; + __le16 vifrsm; + __le16 vigran; + __u8 rsvd80[4016]; +}; + +/** + * struct nvme_secondary_ctrl - + * @scid: Secondary Controller Identifier + * @pcid: Primary Controller Identifier + * @scs: Secondary Controller State + * @rsvd5: Reserved + * @vfn: Virtual Function Number + * @nvq: Number of VQ Flexible Resources Assigned + * @nvi: Number of VI Flexible Resources Assigned + * @rsvd14: Reserved + */ +struct nvme_secondary_ctrl { + __le16 scid; + __le16 pcid; + __u8 scs; + __u8 rsvd5[3]; + __le16 vfn; + __le16 nvq; + __le16 nvi; + __u8 rsvd14[18]; +}; + +/** + * struct nvme_secondary_ctrl_list - + * @num: Number of Identifiers + * @rsvd: Reserved + * @sc_entry: Secondary Controller Entry + */ +struct nvme_secondary_ctrl_list { + __u8 num; + __u8 rsvd[31]; + struct nvme_secondary_ctrl sc_entry[NVME_ID_SECONDARY_CTRL_MAX]; +}; + +/** + * struct nvme_id_iocs - NVMe Identify IO Command Set data structure + * @iocsc: List of supported IO Command Set Combination vectors + */ +struct nvme_id_iocs { + __u64 iocsc[512]; +}; + +/** + * struct nvme_id_domain_attr - Domain Attributes Entry + * @dom_id: Domain Identifier + * @rsvd2: Reserved + * @dom_cap: Total Domain Capacity + * @unalloc_dom_cap: Unallocated Domain Capacity + * @max_egrp_dom_cap: Max Endurance Group Domain Capacity + * @rsvd64: Reserved + */ +struct nvme_id_domain_attr { + __le16 dom_id; + __u8 rsvd2[14]; + __u8 dom_cap[16]; + __u8 unalloc_dom_cap[16]; + __u8 max_egrp_dom_cap[16]; + __u8 rsvd64[64]; +}; + +/** + * struct nvme_id_domain_list - + * @num: Number of domain attributes + * @rsvd: Reserved + * @domain_attr: List of domain attributes + */ +struct nvme_id_domain_list { + __u8 num; + __u8 rsvd[127]; + struct nvme_id_domain_attr domain_attr[NVME_ID_DOMAIN_LIST_MAX]; +}; + +/** + * struct nvme_id_endurance_group_list - + * @num: Number of Identifiers + * @identifier: Endurance Group Identifier + */ +struct nvme_id_endurance_group_list { + __le16 num; + __le16 identifier[NVME_ID_ENDURANCE_GROUP_LIST_MAX]; +}; + +/** + * struct nvme_supported_log_pages - + * @lid_support: Log Page Identifier Supported + * + * Supported Log Pages (Log Identifier 00h) + */ +struct nvme_supported_log_pages { + __le32 lid_support[NVME_LOG_SUPPORTED_LOG_PAGES_MAX]; +}; + +/** + * struct nvme_error_log_page - Error Information Log Entry (Log Identifier 01h) + * @error_count: Error Count: a 64-bit incrementing error count, + * indicating a unique identifier for this error. The error + * count starts at %1h, is incremented for each unique error + * log entry, and is retained across power off conditions. + * A value of %0h indicates an invalid entry; this value + * is used when there are lost entries or when there are + * fewer errors than the maximum number of entries the + * controller supports. If the value of this field is + * %FFFFFFFFh, then the field shall be set to 1h when + * incremented (i.e., rolls over to %1h). Prior to NVMe + * 1.4, processing of incrementing beyond %FFFFFFFFh is + * unspecified. + * @sqid: Submission Queue ID: indicates the Submission Queue + * Identifier of the command that the error information is + * associated with. If the error is not specific to + * a particular command, then this field shall be set to + * %FFFFh. + * @cmdid: Command ID: indicates the Command Identifier of the + * command that the error is associated with. If the error + * is not specific to a particular command, then this field + * shall be set to %FFFFh. + * @status_field: Bits 15-1: Status Field: indicates the Status Field for + * the command that completed. If the error is not specific + * to a particular command, then this field reports the most + * applicable status value. + * Bit 0: Phase Tag: may indicate the Phase Tag posted for + * the command. + * @parm_error_location: Parameter Error Location: indicates the byte and bit of + * the command parameter that the error is associated with, + * if applicable. If the parameter spans multiple bytes or + * bits, then the location indicates the first byte and bit + * of the parameter. + * Bits 10-8: Bit in command that contained the error. + * Valid values are 0 to 7. + * Bits 7-0: Byte in command that contained the error. + * Valid values are 0 to 63. + * @lba: LBA: This field indicates the first LBA that experienced + * the error condition, if applicable. + * @nsid: Namespace: This field indicates the NSID of the namespace + * that the error is associated with, if applicable. + * @vs: Vendor Specific Information Available: If there is + * additional vendor specific error information available, + * this field provides the log page identifier associated + * with that page. A value of %0h indicates that no additional + * information is available. Valid values are in the range + * of %80h to %FFh. + * @trtype: Transport Type (TRTYPE): indicates the Transport Type of + * the transport associated with the error. The values in + * this field are the same as the TRTYPE values in the + * Discovery Log Page Entry. If the error is not transport + * related, this field shall be cleared to %0h. If the error + * is transport related, this field shall be set to the type + * of the transport - see &enum nvme_trtype. + * @rsvd: Reserved + * @cs: Command Specific Information: This field contains command + * specific information. If used, the command definition + * specifies the information returned. + * @trtype_spec_info: Transport Type Specific Information + * @rsvd2: Reserved + */ +struct nvme_error_log_page { + __le64 error_count; + __le16 sqid; + __le16 cmdid; + __le16 status_field; + __le16 parm_error_location; + __le64 lba; + __le32 nsid; + __u8 vs; + __u8 trtype; + __u8 rsvd[2]; + __le64 cs; + __le16 trtype_spec_info; + __u8 rsvd2[22]; +}; + +/** + * enum nvme_err_pel - + * @NVME_ERR_PEL_BYTE_MASK: + * @NVME_ERR_PEL_BIT_MASK: + */ +enum nvme_err_pel { + NVME_ERR_PEL_BYTE_MASK = 0xf, + NVME_ERR_PEL_BIT_MASK = 0x70, +}; + +/** + * struct nvme_smart_log - SMART / Health Information Log (Log Identifier 02h) + * @critical_warning: This field indicates critical warnings for the state + * of the controller. Critical warnings may result in an + * asynchronous event notification to the host. Bits in + * this field represent the current associated state and + * are not persistent (see &enum nvme_smart_crit). + * @temperature: Composite Temperature: Contains a value corresponding + * to a temperature in Kelvins that represents the current + * composite temperature of the controller and namespace(s) + * associated with that controller. The manner in which + * this value is computed is implementation specific and + * may not represent the actual temperature of any physical + * point in the NVM subsystem. Warning and critical + * overheating composite temperature threshold values are + * reported by the WCTEMP and CCTEMP fields in the Identify + * Controller data structure. + * @avail_spare: Available Spare: Contains a normalized percentage (0% + * to 100%) of the remaining spare capacity available. + * @spare_thresh: Available Spare Threshold: When the Available Spare + * falls below the threshold indicated in this field, an + * asynchronous event completion may occur. The value is + * indicated as a normalized percentage (0% to 100%). + * The values 101 to 255 are reserved. + * @percent_used: Percentage Used: Contains a vendor specific estimate + * of the percentage of NVM subsystem life used based on + * the actual usage and the manufacturer's prediction of + * NVM life. A value of 100 indicates that the estimated + * endurance of the NVM in the NVM subsystem has been + * consumed, but may not indicate an NVM subsystem failure. + * The value is allowed to exceed 100. Percentages greater + * than 254 shall be represented as 255. This value shall + * be updated once per power-on hour (when the controller + * is not in a sleep state). + * @endu_grp_crit_warn_sumry: Endurance Group Critical Warning Summary: This field + * indicates critical warnings for the state of Endurance + * Groups. Bits in this field represent the current associated + * state and are not persistent (see &enum nvme_smart_egcw). + * @rsvd7: Reserved + * @data_units_read: Data Units Read: Contains the number of 512 byte data + * units the host has read from the controller; this value + * does not include metadata. This value is reported in + * thousands (i.e., a value of 1 corresponds to 1000 + * units of 512 bytes read) and is rounded up (e.g., one + * indicates the that number of 512 byte data units read + * is from 1 to 1000, three indicates that the number of + * 512 byte data units read is from 2001 to 3000). When + * the LBA size is a value other than 512 bytes, the + * controller shall convert the amount of data read to + * 512 byte units. For the NVM command set, logical blocks + * read as part of Compare, Read, and Verify operations + * shall be included in this value. A value of %0h in + * this field indicates that the number of Data Units Read + * is not reported. + * @data_units_written: Data Units Written: Contains the number of 512 byte + * data units the host has written to the controller; + * this value does not include metadata. This value is + * reported in thousands (i.e., a value of 1 corresponds + * to 1000 units of 512 bytes written) and is rounded up + * (e.g., one indicates that the number of 512 byte data + * units written is from 1 to 1,000, three indicates that + * the number of 512 byte data units written is from 2001 + * to 3000). When the LBA size is a value other than 512 + * bytes, the controller shall convert the amount of data + * written to 512 byte units. For the NVM command set, + * logical blocks written as part of Write operations shall + * be included in this value. Write Uncorrectable commands + * and Write Zeroes commands shall not impact this value. + * A value of %0h in this field indicates that the number + * of Data Units Written is not reported. + * @host_reads: Host Read Commands: Contains the number of read commands + * completed by the controller. For the NVM command set, + * this value is the sum of the number of Compare commands + * and the number of Read commands. + * @host_writes: Host Write Commands: Contains the number of write + * commands completed by the controller. For the NVM + * command set, this is the number of Write commands. + * @ctrl_busy_time: Controller Busy Time: Contains the amount of time the + * controller is busy with I/O commands. The controller + * is busy when there is a command outstanding to an I/O + * Queue (specifically, a command was issued via an I/O + * Submission Queue Tail doorbell write and the corresponding + * completion queue entry has not been posted yet to the + * associated I/O Completion Queue). This value is + * reported in minutes. + * @power_cycles: Power Cycles: Contains the number of power cycles. + * @power_on_hours: Power On Hours: Contains the number of power-on hours. + * This may not include time that the controller was + * powered and in a non-operational power state. + * @unsafe_shutdowns: Unsafe Shutdowns: Contains the number of unsafe + * shutdowns. This count is incremented when a Shutdown + * Notification (CC.SHN) is not received prior to loss of power. + * @media_errors: Media and Data Integrity Errors: Contains the number + * of occurrences where the controller detected an + * unrecovered data integrity error. Errors such as + * uncorrectable ECC, CRC checksum failure, or LBA tag + * mismatch are included in this field. Errors introduced + * as a result of a Write Uncorrectable command may or + * may not be included in this field. + * @num_err_log_entries: Number of Error Information Log Entries: Contains the + * number of Error Information log entries over the life + * of the controller. + * @warning_temp_time: Warning Composite Temperature Time: Contains the amount + * of time in minutes that the controller is operational + * and the Composite Temperature is greater than or equal + * to the Warning Composite Temperature Threshold (WCTEMP) + * field and less than the Critical Composite Temperature + * Threshold (CCTEMP) field in the Identify Controller + * data structure. If the value of the WCTEMP or CCTEMP + * field is %0h, then this field is always cleared to %0h + * regardless of the Composite Temperature value. + * @critical_comp_time: Critical Composite Temperature Time: Contains the amount + * of time in minutes that the controller is operational + * and the Composite Temperature is greater than or equal + * to the Critical Composite Temperature Threshold (CCTEMP) + * field in the Identify Controller data structure. If + * the value of the CCTEMP field is %0h, then this field + * is always cleared to 0h regardless of the Composite + * Temperature value. + * @temp_sensor: Temperature Sensor 1-8: Contains the current temperature + * in degrees Kelvin reported by temperature sensors 1-8. + * The physical point in the NVM subsystem whose temperature + * is reported by the temperature sensor and the temperature + * accuracy is implementation specific. An implementation + * that does not implement the temperature sensor reports + * a value of %0h. + * @thm_temp1_trans_count: Thermal Management Temperature 1 Transition Count: + * Contains the number of times the controller transitioned + * to lower power active power states or performed vendor + * specific thermal management actions while minimizing + * the impact on performance in order to attempt to reduce + * the Composite Temperature because of the host controlled + * thermal management feature (i.e., the Composite + * Temperature rose above the Thermal Management + * Temperature 1). This counter shall not wrap once the + * value %FFFFFFFFh is reached. A value of %0h, indicates + * that this transition has never occurred or this field + * is not implemented. + * @thm_temp2_trans_count: Thermal Management Temperature 2 Transition Count + * @thm_temp1_total_time: Total Time For Thermal Management Temperature 1: + * Contains the number of seconds that the controller + * had transitioned to lower power active power states or + * performed vendor specific thermal management actions + * while minimizing the impact on performance in order to + * attempt to reduce the Composite Temperature because of + * the host controlled thermal management feature. This + * counter shall not wrap once the value %FFFFFFFFh is + * reached. A value of %0h, indicates that this transition + * has never occurred or this field is not implemented. + * @thm_temp2_total_time: Total Time For Thermal Management Temperature 2 + * @rsvd232: Reserved + */ +struct nvme_smart_log { + __u8 critical_warning; + __u8 temperature[2]; + __u8 avail_spare; + __u8 spare_thresh; + __u8 percent_used; + __u8 endu_grp_crit_warn_sumry; + __u8 rsvd7[25]; + __u8 data_units_read[16]; + __u8 data_units_written[16]; + __u8 host_reads[16]; + __u8 host_writes[16]; + __u8 ctrl_busy_time[16]; + __u8 power_cycles[16]; + __u8 power_on_hours[16]; + __u8 unsafe_shutdowns[16]; + __u8 media_errors[16]; + __u8 num_err_log_entries[16]; + __le32 warning_temp_time; + __le32 critical_comp_time; + __le16 temp_sensor[8]; + __le32 thm_temp1_trans_count; + __le32 thm_temp2_trans_count; + __le32 thm_temp1_total_time; + __le32 thm_temp2_total_time; + __u8 rsvd232[280]; +}; + +/** + * enum nvme_smart_crit - Critical Warning + * @NVME_SMART_CRIT_SPARE: If set, then the available spare capacity has fallen + * below the threshold. + * @NVME_SMART_CRIT_TEMPERATURE: If set, then a temperature is either greater + * than or equal to an over temperature threshold; or + * less than or equal to an under temperature threshold. + * @NVME_SMART_CRIT_DEGRADED: If set, then the NVM subsystem reliability has + * been degraded due to significant media related errors + * or any internal error that degrades NVM subsystem + * reliability. + * @NVME_SMART_CRIT_MEDIA: If set, then all of the media has been placed in read + * only mode. The controller shall not set this bit if + * the read-only condition on the media is a result of + * a change in the write protection state of a namespace. + * @NVME_SMART_CRIT_VOLATILE_MEMORY: If set, then the volatile memory backup + * device has failed. This field is only valid if the + * controller has a volatile memory backup solution. + * @NVME_SMART_CRIT_PMR_RO: If set, then the Persistent Memory Region has become + * read-only or unreliable. + */ +enum nvme_smart_crit { + NVME_SMART_CRIT_SPARE = 1 << 0, + NVME_SMART_CRIT_TEMPERATURE = 1 << 1, + NVME_SMART_CRIT_DEGRADED = 1 << 2, + NVME_SMART_CRIT_MEDIA = 1 << 3, + NVME_SMART_CRIT_VOLATILE_MEMORY = 1 << 4, + NVME_SMART_CRIT_PMR_RO = 1 << 5, +}; + +/** + * enum nvme_smart_egcw - Endurance Group Critical Warning Summary + * @NVME_SMART_EGCW_SPARE: If set, then the available spare capacity of one or + * more Endurance Groups has fallen below the threshold. + * @NVME_SMART_EGCW_DEGRADED: If set, then the reliability of one or more + * Endurance Groups has been degraded due to significant + * media related errors or any internal error that + * degrades NVM subsystem reliability. + * @NVME_SMART_EGCW_RO: If set, then the namespaces in one or more Endurance + * Groups have been placed in read only mode not as + * a result of a change in the write protection state + * of a namespace. + */ +enum nvme_smart_egcw { + NVME_SMART_EGCW_SPARE = 1 << 0, + NVME_SMART_EGCW_DEGRADED = 1 << 2, + NVME_SMART_EGCW_RO = 1 << 3, +}; + +/** + * struct nvme_firmware_slot - + * @afi: Active Firmware Info + * @rsvd1: Reserved + * @frs: Firmware Revision for Slot + * @rsvd2: Reserved + */ +struct nvme_firmware_slot { + __u8 afi; + __u8 rsvd1[7]; + char frs[7][8]; + __u8 rsvd2[448]; +}; + +/** + * struct nvme_cmd_effects_log - + * @acs: Admin Command Supported + * @iocs: I/O Command Supported + * @rsvd: Reserved + */ +struct nvme_cmd_effects_log { + __le32 acs[256]; + __le32 iocs[256]; + __u8 rsvd[2048]; +}; + +/** + * enum nvme_cmd_effects - + * @NVME_CMD_EFFECTS_CSUPP: Command Supported + * @NVME_CMD_EFFECTS_LBCC: Logical Block Content Change + * @NVME_CMD_EFFECTS_NCC: Namespace Capability Change + * @NVME_CMD_EFFECTS_NIC: Namespace Inventory Change + * @NVME_CMD_EFFECTS_CCC: Controller Capability Change + * @NVME_CMD_EFFECTS_CSE_MASK: Command Submission and Execution + * @NVME_CMD_EFFECTS_UUID_SEL: UUID Selection Supported + */ +enum nvme_cmd_effects { + NVME_CMD_EFFECTS_CSUPP = 1 << 0, + NVME_CMD_EFFECTS_LBCC = 1 << 1, + NVME_CMD_EFFECTS_NCC = 1 << 2, + NVME_CMD_EFFECTS_NIC = 1 << 3, + NVME_CMD_EFFECTS_CCC = 1 << 4, + NVME_CMD_EFFECTS_CSE_MASK = 3 << 16, + NVME_CMD_EFFECTS_UUID_SEL = 1 << 19, +}; + +/** + * struct nvme_st_result - Self-test Result + * @dsts: Device Self-test Status: Indicates the device self-test code and the + * status of the operation (see &enum nvme_status_result and &enum nvme_st_code). + * @seg: Segment Number: Iindicates the segment number where the first self-test + * failure occurred. If Device Self-test Status (@dsts) is not set to + * #NVME_ST_RESULT_KNOWN_SEG_FAIL, then this field should be ignored. + * @vdi: Valid Diagnostic Information: Indicates the diagnostic failure + * information that is reported. See &enum nvme_st_valid_diag_info. + * @rsvd: Reserved + * @poh: Power On Hours (POH): Indicates the number of power-on hours at the + * time the device self-test operation was completed or aborted. This + * does not include time that the controller was powered and in a low + * power state condition. + * @nsid: Namespace Identifier (NSID): Indicates the namespace that the Failing + * LBA occurred on. Valid only when the NSID Valid bit + * (#NVME_ST_VALID_DIAG_INFO_NSID) is set in the Valid Diagnostic + * Information (@vdi) field. + * @flba: Failing LBA: indicates the LBA of the logical block that caused the + * test to fail. If the device encountered more than one failed logical + * block during the test, then this field only indicates one of those + * failed logical blocks. Valid only when the NSID Valid bit + * (#NVME_ST_VALID_DIAG_INFO_FLBA) is set in the Valid Diagnostic + * Information (@vdi) field. + * @sct: Status Code Type: This field may contain additional information related + * to errors or conditions. Bits 2:0 may contain additional information + * relating to errors or conditions that occurred during the device + * self-test operation represented in the same format used in the Status + * Code Type field of the completion queue entry (refer to &enum nvme_status_field). + * Valid only when the NSID Valid bit (#NVME_ST_VALID_DIAG_INFO_SCT) is + * set in the Valid Diagnostic Information (@vdi) field. + * @sc: Status Code: This field may contain additional information relating + * to errors or conditions that occurred during the device self-test + * operation represented in the same format used in the Status Code field + * of the completion queue entry. Valid only when the SCT Valid bit + * (#NVME_ST_VALID_DIAG_INFO_SC) is set in the Valid Diagnostic + * Information (@vdi) field. + * @vs: Vendor Specific. + */ +struct nvme_st_result { + __u8 dsts; + __u8 seg; + __u8 vdi; + __u8 rsvd; + __le64 poh; + __le32 nsid; + __le64 flba; + __u8 sct; + __u8 sc; + __u8 vs[2]; +} __attribute__((packed)); + +/** + * enum nvme_status_result - Result of the device self-test operation + * @NVME_ST_RESULT_NO_ERR: Operation completed without error. + * @NVME_ST_RESULT_ABORTED: Operation was aborted by a Device Self-test command. + * @NVME_ST_RESULT_CLR: Operation was aborted by a Controller Level Reset. + * @NVME_ST_RESULT_NS_REMOVED: Operation was aborted due to a removal of + * a namespace from the namespace inventory. + * @NVME_ST_RESULT_ABORTED_FORMAT: Operation was aborted due to the processing + * of a Format NVM command. + * @NVME_ST_RESULT_FATAL_ERR: A fatal error or unknown test error occurred + * while the controller was executing the device + * self-test operation and the operation did + * not complete. + * @NVME_ST_RESULT_UNKNOWN_SEG_FAIL: Operation completed with a segment that failed + * and the segment that failed is not known. + * @NVME_ST_RESULT_KNOWN_SEG_FAIL: Operation completed with one or more failed + * segments and the first segment that failed + * is indicated in the Segment Number field. + * @NVME_ST_RESULT_ABORTED_UNKNOWN: Operation was aborted for unknown reason. + * @NVME_ST_RESULT_ABORTED_SANITIZE: Operation was aborted due to a sanitize operation. + * @NVME_ST_RESULT_NOT_USED: Entry not used (does not contain a test result). + * @NVME_ST_RESULT_MASK: Mask to get the status result value from + * the &struct nvme_st_result.dsts field. + */ +enum nvme_status_result { + NVME_ST_RESULT_NO_ERR = 0x0, + NVME_ST_RESULT_ABORTED = 0x1, + NVME_ST_RESULT_CLR = 0x2, + NVME_ST_RESULT_NS_REMOVED = 0x3, + NVME_ST_RESULT_ABORTED_FORMAT = 0x4, + NVME_ST_RESULT_FATAL_ERR = 0x5, + NVME_ST_RESULT_UNKNOWN_SEG_FAIL = 0x6, + NVME_ST_RESULT_KNOWN_SEG_FAIL = 0x7, + NVME_ST_RESULT_ABORTED_UNKNOWN = 0x8, + NVME_ST_RESULT_ABORTED_SANITIZE = 0x9, + NVME_ST_RESULT_NOT_USED = 0xf, + NVME_ST_RESULT_MASK = 0xf, +}; + +/** + * enum nvme_st_code - Self-test Code value + * @NVME_ST_CODE_RESERVED: Reserved. + * @NVME_ST_CODE_SHORT: Short device self-test operation. + * @NVME_ST_CODE_EXTENDED: Extended device self-test operation. + * @NVME_ST_CODE_VS: Vendor specific. + * @NVME_ST_CODE_SHIFT: Shift amount to get the code value from the + * &struct nvme_st_result.dsts field. + */ +enum nvme_st_code { + NVME_ST_CODE_RESERVED = 0x0, + NVME_ST_CODE_SHORT = 0x1, + NVME_ST_CODE_EXTENDED = 0x2, + NVME_ST_CODE_VS = 0xe, + NVME_ST_CODE_SHIFT = 4, +}; + +/** + * enum nvme_st_curr_op - Current Device Self-Test Operation + * @NVME_ST_CURR_OP_NOT_RUNNING: No device self-test operation in progress. + * @NVME_ST_CURR_OP_SHORT: Short device self-test operation in progress. + * @NVME_ST_CURR_OP_EXTENDED: Extended device self-test operation in progress. + * @NVME_ST_CURR_OP_VS: Vendor specific. + * @NVME_ST_CURR_OP_RESERVED: Reserved. + * @NVME_ST_CURR_OP_MASK: Mask to get the current operation value from the + * &struct nvme_self_test_log.current_operation field. + * @NVME_ST_CURR_OP_CMPL_MASK: Mask to get the current operation completion value + * from the &struct nvme_self_test_log.completion field. + */ +enum nvme_st_curr_op { + NVME_ST_CURR_OP_NOT_RUNNING = 0x0, + NVME_ST_CURR_OP_SHORT = 0x1, + NVME_ST_CURR_OP_EXTENDED = 0x2, + NVME_ST_CURR_OP_VS = 0xe, + NVME_ST_CURR_OP_RESERVED = 0xf, + NVME_ST_CURR_OP_MASK = 0xf, + NVME_ST_CURR_OP_CMPL_MASK = 0x7f, +}; + +/** + * enum nvme_st_valid_diag_info - Valid Diagnostic Information + * @NVME_ST_VALID_DIAG_INFO_NSID: NSID Valid: if set, then the contents of + * the Namespace Identifier field are valid. + * @NVME_ST_VALID_DIAG_INFO_FLBA: FLBA Valid: if set, then the contents of + * the Failing LBA field are valid. + * @NVME_ST_VALID_DIAG_INFO_SCT: SCT Valid: if set, then the contents of + * the Status Code Type field are valid. + * @NVME_ST_VALID_DIAG_INFO_SC: SC Valid: if set, then the contents of + * the Status Code field are valid. + */ +enum nvme_st_valid_diag_info { + NVME_ST_VALID_DIAG_INFO_NSID = 1 << 0, + NVME_ST_VALID_DIAG_INFO_FLBA = 1 << 1, + NVME_ST_VALID_DIAG_INFO_SCT = 1 << 2, + NVME_ST_VALID_DIAG_INFO_SC = 1 << 3, +}; + +/** + * struct nvme_self_test_log - Device Self-test (Log Identifier 06h) + * @current_operation: Current Device Self-Test Operation: indicates the status + * of the current device self-test operation. If a device + * self-test operation is in process (i.e., this field is set + * to #NVME_ST_CURR_OP_SHORT or #NVME_ST_CURR_OP_EXTENDED), + * then the controller shall not set this field to + * #NVME_ST_CURR_OP_NOT_RUNNING until a new Self-test Result + * Data Structure is created (i.e., if a device self-test + * operation completes or is aborted, then the controller + * shall create a Self-test Result Data Structure prior to + * setting this field to #NVME_ST_CURR_OP_NOT_RUNNING). + * See &enum nvme_st_curr_op. + * @completion: Current Device Self-Test Completion: indicates the percentage + * of the device self-test operation that is complete (e.g., + * a value of 25 indicates that 25% of the device self-test + * operation is complete and 75% remains to be tested). + * If the @current_operation field is cleared to + * #NVME_ST_CURR_OP_NOT_RUNNING (indicating there is no device + * self-test operation in progress), then this field is ignored. + * @rsvd: Reserved + * @result: Self-test Result Data Structures, see &struct nvme_st_result. + */ +struct nvme_self_test_log { + __u8 current_operation; + __u8 completion; + __u8 rsvd[2]; + struct nvme_st_result result[NVME_LOG_ST_MAX_RESULTS]; +} __attribute__((packed)); + +/** + * enum nvme_cmd_get_log_telemetry_host_lsp - + * @NVME_LOG_TELEM_HOST_LSP_RETAIN: + * @NVME_LOG_TELEM_HOST_LSP_CREATE: + */ +enum nvme_cmd_get_log_telemetry_host_lsp { + NVME_LOG_TELEM_HOST_LSP_RETAIN = 0, + NVME_LOG_TELEM_HOST_LSP_CREATE = 1, +}; + +/** + * struct nvme_telemetry_log - Retrieve internal data specific to the + * manufacturer. + * @lpi: Log Identifier, either %NVME_LOG_LID_TELEMETRY_HOST or + * %NVME_LOG_LID_TELEMETRY_CTRL + * @rsvd1: Reserved + * @ieee: IEEE OUI Identifier is the Organization Unique Identifier (OUI) + * for the controller vendor that is able to interpret the data. + * @dalb1: Telemetry Controller-Initiated Data Area 1 Last Block is + * the value of the last block in this area. + * @dalb2: Telemetry Controller-Initiated Data Area 1 Last Block is + * the value of the last block in this area. + * @dalb3: Telemetry Controller-Initiated Data Area 1 Last Block is + * the value of the last block in this area. + * @rsvd14: Reserved + * @dalb4: Telemetry Controller-Initiated Data Area 4 Last Block is + * the value of the last block in this area. + * @rsvd20: Reserved + * @hostdgn: Telemetry Host-Initiated Data Generation Number is a + * value that is incremented each time the host initiates a + * capture of its internal controller state in the controller . + * @ctrlavail: Telemetry Controller-Initiated Data Available, if cleared, + * then the controller telemetry log does not contain saved + * internal controller state. If this field is set to 1h, the + * controller log contains saved internal controller state. If + * this field is set to 1h, the data will be latched until the + * host releases it by reading the log with RAE cleared. + * @ctrldgn: Telemetry Controller-Initiated Data Generation Number is + * a value that is incremented each time the controller initiates a + * capture of its internal controller state in the controller . + * @rsnident: Reason Identifieris a vendor specific identifier that describes + * the operating conditions of the controller at the time of + * capture. + * @data_area: Telemetry data blocks, vendor specific information data. + * + * This log consists of a header describing the log and zero or more Telemetry + * Data Blocks. All Telemetry Data Blocks are %NVME_LOG_TELEM_BLOCK_SIZE, 512 + * bytes, in size. This log captures the controller’s internal state. + */ +struct nvme_telemetry_log { + __u8 lpi; + __u8 rsvd1[4]; + __u8 ieee[3]; + __le16 dalb1; + __le16 dalb2; + __le16 dalb3; + __u8 rsvd14[2]; + __le32 dalb4; + __u8 rsvd20[361]; + __u8 hostdgn; + __u8 ctrlavail; + __u8 ctrldgn; + __u8 rsnident[128]; + __u8 data_area[]; +}; + +/** + * struct nvme_endurance_group_log - + * @critical_warning: Critical Warning + * @rsvd1: Reserved + * @avl_spare: Available Spare + * @avl_spare_threshold: Available Spare Threshold + * @percent_used: Percentage Used + * @rsvd6: Reserved + * @endurance_estimate: Endurance Estimate + * @data_units_read: Data Units Read + * @data_units_written: Data Units Written + * @media_units_written: Media Units Written + * @host_read_cmds: Host Read Commands + * @host_write_cmds: Host Write Commands + * @media_data_integrity_err: Media and Data Integrity Errors + * @num_err_info_log_entries: Number of Error Information Log Entries + * @rsvd160: Reserved + */ +struct nvme_endurance_group_log { + __u8 critical_warning; + __u8 rsvd1[2]; + __u8 avl_spare; + __u8 avl_spare_threshold; + __u8 percent_used; + __u8 rsvd6[26]; + __u8 endurance_estimate[16]; + __u8 data_units_read[16]; + __u8 data_units_written[16]; + __u8 media_units_written[16]; + __u8 host_read_cmds[16]; + __u8 host_write_cmds[16]; + __u8 media_data_integrity_err[16]; + __u8 num_err_info_log_entries[16]; + __u8 rsvd160[352]; +}; + +/** + * enum nvme_eg_critical_warning_flags - + * @NVME_EG_CRITICAL_WARNING_SPARE: + * @NVME_EG_CRITICAL_WARNING_DEGRADED: + * @NVME_EG_CRITICAL_WARNING_READ_ONLY: + */ +enum nvme_eg_critical_warning_flags { + NVME_EG_CRITICAL_WARNING_SPARE = 1 << 0, + NVME_EG_CRITICAL_WARNING_DEGRADED = 1 << 2, + NVME_EG_CRITICAL_WARNING_READ_ONLY = 1 << 3, +}; + +/** + * struct nvme_aggregate_endurance_group_event - + * @num_entries: Number or entries + * @entries: List of entries + */ +struct nvme_aggregate_endurance_group_event { + __le64 num_entries; + __le16 entries[]; +}; + +/** + * struct nvme_nvmset_predictable_lat_log - + * @status: Status + * @rsvd1: Reserved + * @event_type: Event Type + * @rsvd4: Reserved + * @dtwin_rt: DTWIN Reads Typical + * @dtwin_wt: DTWIN Writes Typical + * @dtwin_tmax: DTWIN Time Maximum + * @ndwin_tmin_hi: NDWIN Time Minimum High + * @ndwin_tmin_lo: NDWIN Time Minimum Low + * @rsvd72: Reserved + * @dtwin_re: DTWIN Reads Estimate + * @dtwin_we: DTWIN Writes Estimate + * @dtwin_te: DTWIN Time Estimate + * @rsvd152: Reserved + */ +struct nvme_nvmset_predictable_lat_log { + __u8 status; + __u8 rsvd1; + __le16 event_type; + __u8 rsvd4[28]; + __le64 dtwin_rt; + __le64 dtwin_wt; + __le64 dtwin_tmax; + __le64 ndwin_tmin_hi; + __le64 ndwin_tmin_lo; + __u8 rsvd72[56]; + __le64 dtwin_re; + __le64 dtwin_we; + __le64 dtwin_te; + __u8 rsvd152[360]; +}; + +/** + * enum nvme_nvmeset_pl_status - + * @NVME_NVMSET_PL_STATUS_DISABLED: + * @NVME_NVMSET_PL_STATUS_DTWIN: + * @NVME_NVMSET_PL_STATUS_NDWIN: + */ +enum nvme_nvmeset_pl_status { + NVME_NVMSET_PL_STATUS_DISABLED = 0, + NVME_NVMSET_PL_STATUS_DTWIN = 1, + NVME_NVMSET_PL_STATUS_NDWIN = 2, +}; + +/** + * enum nvme_nvmset_pl_events - + * @NVME_NVMSET_PL_EVENT_DTWIN_READ_WARN: + * @NVME_NVMSET_PL_EVENT_DTWIN_WRITE_WARN: + * @NVME_NVMSET_PL_EVENT_DTWIN_TIME_WARN: + * @NVME_NVMSET_PL_EVENT_DTWIN_EXCEEDED: + * @NVME_NVMSET_PL_EVENT_DTWIN_EXCURSION: + */ +enum nvme_nvmset_pl_events { + NVME_NVMSET_PL_EVENT_DTWIN_READ_WARN = 1 << 0, + NVME_NVMSET_PL_EVENT_DTWIN_WRITE_WARN = 1 << 1, + NVME_NVMSET_PL_EVENT_DTWIN_TIME_WARN = 1 << 2, + NVME_NVMSET_PL_EVENT_DTWIN_EXCEEDED = 1 << 14, + NVME_NVMSET_PL_EVENT_DTWIN_EXCURSION = 1 << 15, +}; + +/** + * struct nvme_aggregate_predictable_lat_event - + * @num_entries: Number of entries + * @entries: Entry list + */ +struct nvme_aggregate_predictable_lat_event { + __le64 num_entries; + __le16 entries[]; +}; + +/** + * struct nvme_ana_group_desc - + * @grpid: ANA group id + * @nnsids: Number of namespaces in @nsids + * @chgcnt: Change counter + * @state: ANA state + * @rsvd17: Reserved + * @nsids: List of namespaces + */ +struct nvme_ana_group_desc { + __le32 grpid; + __le32 nnsids; + __le64 chgcnt; + __u8 state; + __u8 rsvd17[15]; + __le32 nsids[]; +}; + +/** + * enum nvme_ana_state - + * @NVME_ANA_STATE_OPTIMIZED: + * @NVME_ANA_STATE_NONOPTIMIZED: + * @NVME_ANA_STATE_INACCESSIBLE: + * @NVME_ANA_STATE_PERSISTENT_LOSS: + * @NVME_ANA_STATE_CHANGE: + */ +enum nvme_ana_state { + NVME_ANA_STATE_OPTIMIZED = 0x1, + NVME_ANA_STATE_NONOPTIMIZED = 0x2, + NVME_ANA_STATE_INACCESSIBLE = 0x3, + NVME_ANA_STATE_PERSISTENT_LOSS = 0x4, + NVME_ANA_STATE_CHANGE = 0xf, +}; + +/** + * struct nvme_ana_log - + * @chgcnt: Change Count + * @ngrps: Number of ANA Group Descriptors + * @rsvd10: Reserved + * @descs: ANA Group Descriptor + */ +struct nvme_ana_log { + __le64 chgcnt; + __le16 ngrps; + __u8 rsvd10[6]; + struct nvme_ana_group_desc descs[]; +}; + +/** + * struct nvme_persistent_event_log - + * @lid: Log Identifier + * @rsvd1: Reserved + * @tnev: Total Number of Events + * @tll: Total Log Length + * @rv: Log Revision + * @rsvd17: Reserved + * @lhl: Log Header Length + * @ts: Timestamp + * @poh: Power on Hours + * @pcc: Power Cycle Count + * @vid: PCI Vendor ID + * @ssvid: PCI Subsystem Vendor ID + * @sn: Serial Number + * @mn: Model Number + * @subnqn: NVM Subsystem NVMe Qualified Name + * @gen_number: Generation Number + * @rci: Reporting Context Information + * @rsvd378: Reserved + * @seb: Supported Events Bitmap + */ +struct nvme_persistent_event_log { + __u8 lid; + __u8 rsvd1[3]; + __le32 tnev; + __le64 tll; + __u8 rv; + __u8 rsvd17; + __le16 lhl; + __le64 ts; + __u8 poh[16]; + __le64 pcc; + __le16 vid; + __le16 ssvid; + char sn[20]; + char mn[40]; + char subnqn[NVME_NQN_LENGTH]; + __le16 gen_number; + __le32 rci; + __u8 rsvd378[102]; + __u8 seb[32]; +} __attribute__((packed)); + +/** + * struct nvme_persistent_event_entry - + * @etype: Event Type + * @etype_rev: Event Type Revision + * @ehl: Event Header Length + * @ehai: Event Header Additional Info + * @cntlid: Controller Identifier + * @ets: Event Timestamp + * @pelpid: Port Identifier + * @rsvd16: Reserved + * @vsil: Vendor Specific Information Length + * @el: Event Length + */ +struct nvme_persistent_event_entry { + __u8 etype; + __u8 etype_rev; + __u8 ehl; + __u8 ehai; + __le16 cntlid; + __le64 ets; + __le16 pelpid; + __u8 rsvd16[4]; + __le16 vsil; + __le16 el; +} __attribute__((packed)); + +/** + * enum nvme_persistent_event_types - + * @NVME_PEL_SMART_HEALTH_EVENT: + * @NVME_PEL_FW_COMMIT_EVENT: + * @NVME_PEL_TIMESTAMP_EVENT: + * @NVME_PEL_POWER_ON_RESET_EVENT: + * @NVME_PEL_NSS_HW_ERROR_EVENT: + * @NVME_PEL_CHANGE_NS_EVENT: + * @NVME_PEL_FORMAT_START_EVENT: + * @NVME_PEL_FORMAT_COMPLETION_EVENT: + * @NVME_PEL_SANITIZE_START_EVENT: + * @NVME_PEL_SANITIZE_COMPLETION_EVENT: + * @NVME_PEL_SET_FEATURE_EVENT: + * @NVME_PEL_TELEMETRY_CRT: + * @NVME_PEL_THERMAL_EXCURSION_EVENT: + */ +enum nvme_persistent_event_types { + NVME_PEL_SMART_HEALTH_EVENT = 0x01, + NVME_PEL_FW_COMMIT_EVENT = 0x02, + NVME_PEL_TIMESTAMP_EVENT = 0x03, + NVME_PEL_POWER_ON_RESET_EVENT = 0x04, + NVME_PEL_NSS_HW_ERROR_EVENT = 0x05, + NVME_PEL_CHANGE_NS_EVENT = 0x06, + NVME_PEL_FORMAT_START_EVENT = 0x07, + NVME_PEL_FORMAT_COMPLETION_EVENT = 0x08, + NVME_PEL_SANITIZE_START_EVENT = 0x09, + NVME_PEL_SANITIZE_COMPLETION_EVENT = 0x0a, + NVME_PEL_SET_FEATURE_EVENT = 0x0b, + NVME_PEL_TELEMETRY_CRT = 0x0c, + NVME_PEL_THERMAL_EXCURSION_EVENT = 0x0d, +}; + +/** + * struct nvme_fw_commit_event - + * @old_fw_rev: Old Firmware Revision + * @new_fw_rev: New Firmware Revision + * @fw_commit_action: Firmware Commit Action + * @fw_slot: Firmware Slot + * @sct_fw: Status Code Type for Firmware Commit Command + * @sc_fw: Status Returned for Firmware Commit Command + * @vndr_assign_fw_commit_rc: Vendor Assigned Firmware Commit Result Code + */ +struct nvme_fw_commit_event { + __le64 old_fw_rev; + __le64 new_fw_rev; + __u8 fw_commit_action; + __u8 fw_slot; + __u8 sct_fw; + __u8 sc_fw; + __le16 vndr_assign_fw_commit_rc; +} __attribute__((packed)); + +/** + * struct nvme_time_stamp_change_event - + * @previous_timestamp: Previous Timestamp + * @ml_secs_since_reset: Milliseconds Since Reset + */ +struct nvme_time_stamp_change_event { + __le64 previous_timestamp; + __le64 ml_secs_since_reset; +}; + +/** + * struct nvme_power_on_reset_info_list - + * @cid: Controller ID + * @fw_act: Firmware Activation + * @op_in_prog: Operation in Progress + * @rsvd4: Reserved + * @ctrl_power_cycle: Controller Power Cycle + * @power_on_ml_seconds: Power on milliseconds + * @ctrl_time_stamp: Controller Timestamp + */ +struct nvme_power_on_reset_info_list { + __le16 cid; + __u8 fw_act; + __u8 op_in_prog; + __u8 rsvd4[12]; + __le32 ctrl_power_cycle; + __le64 power_on_ml_seconds; + __le64 ctrl_time_stamp; +} __attribute__((packed)); + +/** + * struct nvme_nss_hw_err_event - + * @nss_hw_err_event_code: NVM Subsystem Hardware Error Event Code + * @rsvd2: Reserved + * @add_hw_err_info: Additional Hardware Error Information + */ +struct nvme_nss_hw_err_event { + __le16 nss_hw_err_event_code; + __u8 rsvd2[2]; + __u8 *add_hw_err_info; +}; + +/** + * struct nvme_change_ns_event - + * @nsmgt_cdw10: Namespace Management CDW10 + * @rsvd4: Reserved + * @nsze: Namespace Size + * @rsvd16: Reserved + * @nscap: Namespace Capacity + * @flbas: Formatted LBA Size + * @dps: End-to-end Data Protection Type Settings + * @nmic: Namespace Multi-path I/O and Namespace Sharing Capabilities + * @rsvd35: Reserved + * @ana_grp_id: ANA Group Identifier + * @nvmset_id: NVM Set Identifier + * @rsvd42: Reserved + * @nsid: Namespace ID + */ +struct nvme_change_ns_event { + __le32 nsmgt_cdw10; + __u8 rsvd4[4]; + __le64 nsze; + __u8 rsvd16[8]; + __le64 nscap; + __u8 flbas; + __u8 dps; + __u8 nmic; + __u8 rsvd35; + __le32 ana_grp_id; + __le16 nvmset_id; + __le16 rsvd42; + __le32 nsid; +}; + +/** + * struct nvme_format_nvm_start_event - + * @nsid: Namespace Identifier + * @fna: Format NVM Attributes + * @rsvd5: Reserved + * @format_nvm_cdw10: Format NVM CDW10 + */ +struct nvme_format_nvm_start_event { + __le32 nsid; + __u8 fna; + __u8 rsvd5[3]; + __le32 format_nvm_cdw10; +}; + +/** + * struct nvme_format_nvm_compln_event - + * @nsid: Namespace Identifier + * @smallest_fpi: Smallest Format Progress Indicator + * @format_nvm_status: Format NVM Status + * @compln_info: Completion Information + * @status_field: Status Field + */ +struct nvme_format_nvm_compln_event { + __le32 nsid; + __u8 smallest_fpi; + __u8 format_nvm_status; + __le16 compln_info; + __le32 status_field; +}; + +/** + * struct nvme_sanitize_start_event - + * @sani_cap: SANICAP + * @sani_cdw10: Sanitize CDW10 + * @sani_cdw11: Sanitize CDW11 + */ +struct nvme_sanitize_start_event { + __le32 sani_cap; + __le32 sani_cdw10; + __le32 sani_cdw11; +}; + +/** + * struct nvme_sanitize_compln_event - + * @sani_prog: Sanitize Progress + * @sani_status: Sanitize Status + * @cmpln_info: Completion Information + * @rsvd6: Reserved + */ +struct nvme_sanitize_compln_event { + __le16 sani_prog; + __le16 sani_status; + __le16 cmpln_info; + __u8 rsvd6[2]; +}; + +/** + * struct nvme_set_feature_event - + * @layout: Set Feature Event Layout + * @cdw_mem: Command Dwords Memory buffer + */ +struct nvme_set_feature_event { + __le32 layout; + __le32 cdw_mem[0]; +}; + +/** + * struct nvme_thermal_exc_event - + * @over_temp: Over Temperature + * @threshold: temperature threshold + */ +struct nvme_thermal_exc_event { + __u8 over_temp; + __u8 threshold; +}; + +/** + * struct nvme_lba_rd - + * @rslba: Range Starting LBA + * @rnlb: Range Number of Logical Blocks + * @rsvd12: Reserved + */ +struct nvme_lba_rd { + __le64 rslba; + __le32 rnlb; + __u8 rsvd12[4]; +}; + +/** + * struct nvme_lbas_ns_element - + * @neid: Namespace Element Identifier + * @nlrd: Number of LBA Range Descriptors + * @ratype: Recommended Action Type + * @rsvd8: Reserved + * @lba_rd: LBA Range Descriptor + */ +struct nvme_lbas_ns_element { + __le32 neid; + __le32 nlrd; + __u8 ratype; + __u8 rsvd8[7]; + struct nvme_lba_rd lba_rd[]; +}; + +/** + * enum nvme_lba_status_atype - + * @NVME_LBA_STATUS_ATYPE_SCAN_UNTRACKED: + * @NVME_LBA_STATUS_ATYPE_SCAN_TRACKED: + */ +enum nvme_lba_status_atype { + NVME_LBA_STATUS_ATYPE_SCAN_UNTRACKED = 0x10, + NVME_LBA_STATUS_ATYPE_SCAN_TRACKED = 0x11, +}; + +/** + * struct nvme_lba_status_log - + * @lslplen: LBA Status Log Page Length + * @nlslne: Number of LBA Status Log Namespace Elements + * @estulb: Estimate of Unrecoverable Logical Blocks + * @rsvd12: Reserved + * @lsgc: LBA Status Generation Counter + * @elements: LBA Status Log Namespace Element List + */ +struct nvme_lba_status_log { + __le32 lslplen; + __le32 nlslne; + __le32 estulb; + __u8 rsvd12[2]; + __le16 lsgc; + struct nvme_lbas_ns_element elements[]; +}; + +/** + * struct nvme_eg_event_aggregate_log - + * @nr_entries: Number of Entries + * @egids: Endurance Group Identifier + */ +struct nvme_eg_event_aggregate_log { + __le64 nr_entries; + __le16 egids[]; +}; + +/** + * enum nvme_fid_supported_effects - + * @NVME_FID_SUPPORTED_EFFECTS_FSUPP: + * @NVME_FID_SUPPORTED_EFFECTS_UDCC: + * @NVME_FID_SUPPORTED_EFFECTS_NCC: + * @NVME_FID_SUPPORTED_EFFECTS_NIC: + * @NVME_FID_SUPPORTED_EFFECTS_CCC: + * @NVME_FID_SUPPORTED_EFFECTS_UUID_SEL: + * @NVME_FID_SUPPORTED_EFFECTS_SCOPE_SHIFT: + * @NVME_FID_SUPPORTED_EFFECTS_SCOPE_MASK: + * @NVME_FID_SUPPORTED_EFFECTS_SCOPE_NS: + * @NVME_FID_SUPPORTED_EFFECTS_SCOPE_CTRL: + * @NVME_FID_SUPPORTED_EFFECTS_SCOPE_NVM_SET: + * @NVME_FID_SUPPORTED_EFFECTS_SCOPE_ENDGRP: + * @NVME_FID_SUPPORTED_EFFECTS_SCOPE_DOMAIN: + * @NVME_FID_SUPPORTED_EFFECTS_SCOPE_NSS: + * + * FID Supported and Effects Data Structure definitions + */ +enum nvme_fid_supported_effects { + NVME_FID_SUPPORTED_EFFECTS_FSUPP = 1 << 0, + NVME_FID_SUPPORTED_EFFECTS_UDCC = 1 << 1, + NVME_FID_SUPPORTED_EFFECTS_NCC = 1 << 2, + NVME_FID_SUPPORTED_EFFECTS_NIC = 1 << 3, + NVME_FID_SUPPORTED_EFFECTS_CCC = 1 << 4, + NVME_FID_SUPPORTED_EFFECTS_UUID_SEL = 1 << 19, + NVME_FID_SUPPORTED_EFFECTS_SCOPE_SHIFT = 20, + NVME_FID_SUPPORTED_EFFECTS_SCOPE_MASK = 0xfff, + NVME_FID_SUPPORTED_EFFECTS_SCOPE_NS = 1 << 0, + NVME_FID_SUPPORTED_EFFECTS_SCOPE_CTRL = 1 << 1, + NVME_FID_SUPPORTED_EFFECTS_SCOPE_NVM_SET= 1 << 2, + NVME_FID_SUPPORTED_EFFECTS_SCOPE_ENDGRP = 1 << 3, + NVME_FID_SUPPORTED_EFFECTS_SCOPE_DOMAIN = 1 << 4, + NVME_FID_SUPPORTED_EFFECTS_SCOPE_NSS = 1 << 5, +}; + +/** + * struct nvme_fid_supported_effects_log - + * @fid_support: Feature Identifier Supported + * + * Feature Identifiers Supported and Effects (Log Identifier 12h) + */ +struct nvme_fid_supported_effects_log { + __le32 fid_support[NVME_LOG_FID_SUPPORTED_EFFECTS_MAX]; +}; + +/** + * enum nvme_mi_cmd_supported_effects - bit field definitions + * @NVME_MI_CMD_SUPPORTED_EFFECTS_CSUPP: Command Supported + * @NVME_MI_CMD_SUPPORTED_EFFECTS_UDCC: User Data Conttent Change + * @NVME_MI_CMD_SUPPORTED_EFFECTS_NCC: Namespace Capability Change + * @NVME_MI_CMD_SUPPORTED_EFFECTS_NIC: Namespace Inventory Change + * @NVME_MI_CMD_SUPPORTED_EFFECTS_CCC: Controller Capability Change + * @NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_SHIFT: 20 bit shift + * @NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_MASK: 12 bit mask - 0xfff + * @NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_NS: Namespace Scope + * @NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_CTRL: Controller Scope + * @NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_NVM_SET: NVM Set Scope + * @NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_ENDGRP: Endurance Group Scope + * @NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_DOMAIN: Domain Scope + * @NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_NSS: NVM Subsystem Scope + * + * MI Command Supported and Effects Data Structure definitions + */ +enum nvme_mi_cmd_supported_effects { + NVME_MI_CMD_SUPPORTED_EFFECTS_CSUPP = 1 << 0, + NVME_MI_CMD_SUPPORTED_EFFECTS_UDCC = 1 << 1, + NVME_MI_CMD_SUPPORTED_EFFECTS_NCC = 1 << 2, + NVME_MI_CMD_SUPPORTED_EFFECTS_NIC = 1 << 3, + NVME_MI_CMD_SUPPORTED_EFFECTS_CCC = 1 << 4, + NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_SHIFT = 20, + NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_MASK = 0xfff, + NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_NS = 1 << 0, + NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_CTRL = 1 << 1, + NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_NVM_SET = 1 << 2, + NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_ENDGRP = 1 << 3, + NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_DOMAIN = 1 << 4, + NVME_MI_CMD_SUPPORTED_EFFECTS_SCOPE_NSS = 1 << 5, +}; + +/** + * struct nvme_mi_cmd_supported_effects_log - + * @mi_cmd_support: NVMe-MI Commands Supported + * + * NVMe-MI Commands Supported and Effects (Log Identifier 13h) + */ +struct nvme_mi_cmd_supported_effects_log { + __le32 mi_cmd_support[NVME_LOG_MI_CMD_SUPPORTED_EFFECTS_MAX]; + __le32 reserved1[NVME_LOG_MI_CMD_SUPPORTED_EFFECTS_RESERVED]; +}; + +/** + * struct nvme_boot_partition - + * @lid: Boot Partition Identifier + * @rsvd1: Reserved + * @bpinfo: Boot Partition Information + * @rsvd8: Reserved + * @boot_partition_data: Contains the contents of the + * specified Boot Partition + */ +struct nvme_boot_partition { + __u8 lid; + __u8 rsvd1[3]; + __le32 bpinfo; + __u8 rsvd8[8]; + __u8 boot_partition_data[]; +}; + +/** + * struct nvme_media_unit_stat_desc - + * @muid: Media Unit Identifier + * @domainid: Domain Identifier + * @endgid: Endurance Group Identifier + * @nvmsetid: NVM Set Identifier + * @cap_adj_fctr: Capacity Adjustment Factor + * @avl_spare: Available Spare + * @percent_used: Percentage Used + * @mucs: Number of Channels attached to media units + * @cio: Channel Identifiers Offset + */ +struct nvme_media_unit_stat_desc { + __le16 muid; + __le16 domainid; + __le16 endgid; + __le16 nvmsetid; + __le16 cap_adj_fctr; + __u8 avl_spare; + __u8 percent_used; + __u8 mucs; + __u8 cio; +}; + +/** + * struct nvme_media_unit_stat_log - + * @nmu: Number unit status descriptor + * @cchans: Number of Channels + * @sel_config: Selected Configuration + * @rsvd6: Reserved + * @mus_desc: Media unit statistic descriptors + */ +struct nvme_media_unit_stat_log { + __le16 nmu; + __le16 cchans; + __le16 sel_config; + __u8 rsvd6[10]; + struct nvme_media_unit_stat_desc mus_desc[]; +}; + +/** + * struct nvme_media_unit_config_desc - + * @muid: Media Unit Identifier + * @mudl: Media Unit Descriptor Length + * + * Media Unit Configuration Descriptor + * Structure Definitions + */ +struct nvme_media_unit_config_desc { + __le16 muid; + __u8 rsvd2[4]; + __le16 mudl; +}; + +/** + * struct nvme_channel_config_desc - + * @chanid: Channel Identifier + * @chmus: Number Channel Media Units + * + * Channel Configuration Descriptor + * Structure Definitions + */ +struct nvme_channel_config_desc { + __le16 chanid; + __le16 chmus; + struct nvme_media_unit_config_desc mu_config_desc[]; +}; + +/** + * struct nvme_end_grp_chan_desc - + * @egchans: Number of Channels + * + * Endurance group Channel Configuration Descriptor + * Structure Definitions + */ +struct nvme_end_grp_chan_desc { + __le16 egchans; + struct nvme_channel_config_desc chan_config_desc[]; +}; + +/** + * struct nvme_end_grp_config_desc - + * @endgid: Endurance Group Identifier + * @cap_adj_factor: Capacity Adjustment Factor + * @tegcap: Total Endurance Group Capacity + * @segcap: Spare Endurance Group Capacity + * @end_est: Endurance Estimate + * @egsets: Number of NVM Sets + * @nvmsetid: NVM Set Identifier + * + * Endurance Group Configuration Descriptor + * Structure Definitions + */ +struct nvme_end_grp_config_desc { + __le16 endgid; + __le16 cap_adj_factor; + __u8 rsvd4[12]; + __u8 tegcap[16]; + __u8 segcap[16]; + __u8 end_est[16]; + __u8 rsvd64[16]; + __le16 egsets; + __le16 nvmsetid[]; +}; + +/** + * struct nvme_cap_config_desc - + * @cap_config_id: Capacity Configuration Identifier + * @domainid: Domain Identifier + * @egcn: Number Endurance Group Configuration + * Descriptors + * + * Capacity Configuration structure definitions + */ +struct nvme_capacity_config_desc { + __le16 cap_config_id; + __le16 domainid; + __le16 egcn; + __u8 rsvd6[26]; + struct nvme_end_grp_config_desc egcd[]; +}; + +/** + * struct nvme_supported_cap_config_list_log - + * @sccn: number of capacity configuration + * + * Supported Capacity Configuration list log page + * structure definitions + */ +struct nvme_supported_cap_config_list_log { + __u8 sccn; + __u8 rsvd1[15]; + struct nvme_capacity_config_desc cap_config_desc[]; +}; + +/** + * struct nvme_resv_notification_log - + * @lpc: Log Page Count + * @rnlpt: See &enum nvme_resv_notify_rnlpt. + * @nalp: Number of Available Log Pages + * @rsvd9: Reserved + * @nsid: Namespace ID + * @rsvd16: Reserved + */ +struct nvme_resv_notification_log { + __le64 lpc; + __u8 rnlpt; + __u8 nalp; + __u8 rsvd9[2]; + __le32 nsid; + __u8 rsvd16[48]; +}; + +/** + * enum nvme_resv_notify_rnlpt - + * @NVME_RESV_NOTIFY_RNLPT_EMPTY: + * @NVME_RESV_NOTIFY_RNLPT_REGISTRATION_PREEMPTED: + * @NVME_RESV_NOTIFY_RNLPT_RESERVATION_RELEASED: + * @NVME_RESV_NOTIFY_RNLPT_RESERVATION_PREEMPTED: + */ +enum nvme_resv_notify_rnlpt { + NVME_RESV_NOTIFY_RNLPT_EMPTY = 0, + NVME_RESV_NOTIFY_RNLPT_REGISTRATION_PREEMPTED = 1, + NVME_RESV_NOTIFY_RNLPT_RESERVATION_RELEASED = 2, + NVME_RESV_NOTIFY_RNLPT_RESERVATION_PREEMPTED = 3, +}; + +/** + * struct nvme_sanitize_log_page - Sanitize Status (Log Identifier 81h) + * @sprog: Sanitize Progress (SPROG): indicates the fraction complete of the + * sanitize operation. The value is a numerator of the fraction + * complete that has 65,536 (10000h) as its denominator. This value + * shall be set to FFFFh if the @sstat field is not set to + * %NVME_SANITIZE_SSTAT_STATUS_IN_PROGESS. + * @sstat: Sanitize Status (SSTAT): indicates the status associated with + * the most recent sanitize operation. See &enum nvme_sanitize_sstat. + * @scdw10: Sanitize Command Dword 10 Information (SCDW10): contains the value + * of the Command Dword 10 field of the Sanitize command that started + * the sanitize operation. + * @eto: Estimated Time For Overwrite: indicates the number of seconds required + * to complete an Overwrite sanitize operation with 16 passes in + * the background when the No-Deallocate Modifies Media After Sanitize + * field is not set to 10b. A value of 0h indicates that the sanitize + * operation is expected to be completed in the background when the + * Sanitize command that started that operation is completed. A value + * of FFFFFFFFh indicates that no time period is reported. + * @etbe: Estimated Time For Block Erase: indicates the number of seconds + * required to complete a Block Erase sanitize operation in the + * background when the No-Deallocate Modifies Media After Sanitize + * field is not set to 10b. A value of 0h indicates that the sanitize + * operation is expected to be completed in the background when the + * Sanitize command that started that operation is completed. + * A value of FFFFFFFFh indicates that no time period is reported. + * @etce: Estimated Time For Crypto Erase: indicates the number of seconds + * required to complete a Crypto Erase sanitize operation in the + * background when the No-Deallocate Modifies Media After Sanitize + * field is not set to 10b. A value of 0h indicates that the sanitize + * operation is expected to be completed in the background when the + * Sanitize command that started that operation is completed. + * A value of FFFFFFFFh indicates that no time period is reported. + * @etond: Estimated Time For Overwrite With No-Deallocate Media Modification: + * indicates the number of seconds required to complete an Overwrite + * sanitize operation and the associated additional media modification + * after the Overwrite sanitize operation in the background when + * the No-Deallocate After Sanitize bit was set to 1 in the Sanitize + * command that requested the Overwrite sanitize operation; and + * the No-Deallocate Modifies Media After Sanitize field is set to 10b. + * A value of 0h indicates that the sanitize operation is expected + * to be completed in the background when the Sanitize command that + * started that operation is completed. A value of FFFFFFFFh indicates + * that no time period is reported. + * @etbend: Estimated Time For Block Erase With No-Deallocate Media Modification: + * indicates the number of seconds required to complete a Block Erase + * sanitize operation and the associated additional media modification + * after the Block Erase sanitize operation in the background when + * the No-Deallocate After Sanitize bit was set to 1 in the Sanitize + * command that requested the Overwrite sanitize operation; and + * the No-Deallocate Modifies Media After Sanitize field is set to 10b. + * A value of 0h indicates that the sanitize operation is expected + * to be completed in the background when the Sanitize command that + * started that operation is completed. A value of FFFFFFFFh indicates + * that no time period is reported. + * @etcend: Estimated Time For Crypto Erase With No-Deallocate Media Modification: + * indicates the number of seconds required to complete a Crypto Erase + * sanitize operation and the associated additional media modification + * after the Crypto Erase sanitize operation in the background when + * the No-Deallocate After Sanitize bit was set to 1 in the Sanitize + * command that requested the Overwrite sanitize operation; and + * the No-Deallocate Modifies Media After Sanitize field is set to 10b. + * A value of 0h indicates that the sanitize operation is expected + * to be completed in the background when the Sanitize command that + * started that operation is completed. A value of FFFFFFFFh indicates + * that no time period is reported. + * @rsvd32: Reserved + */ +struct nvme_sanitize_log_page { + __le16 sprog; + __le16 sstat; + __le32 scdw10; + __le32 eto; + __le32 etbe; + __le32 etce; + __le32 etond; + __le32 etbend; + __le32 etcend; + __u8 rsvd32[480]; +}; + +/** + * enum nvme_sanitize_sstat - Sanitize Status (SSTAT) + * @NVME_SANITIZE_SSTAT_STATUS_SHIFT: Shift amount to get the status value of + * the most recent sanitize operation from + * the &struct nvme_sanitize_log_page.sstat + * field. + * @NVME_SANITIZE_SSTAT_STATUS_MASK: Mask to get the status value of the most + * recent sanitize operation. + * @NVME_SANITIZE_SSTAT_STATUS_NEVER_SANITIZED: The NVM subsystem has never been + * sanitized. + * @NVME_SANITIZE_SSTAT_STATUS_COMPLETE_SUCCESS: The most recent sanitize operation + * completed successfully including any + * additional media modification. + * @NVME_SANITIZE_SSTAT_STATUS_IN_PROGESS: A sanitize operation is currently in progress. + * @NVME_SANITIZE_SSTAT_STATUS_COMPLETED_FAILED: The most recent sanitize operation + * failed. + * @NVME_SANITIZE_SSTAT_STATUS_ND_COMPLETE_SUCCESS: The most recent sanitize operation + * for which No-Deallocate After Sanitize was + * requested has completed successfully with + * deallocation of all user data. + * @NVME_SANITIZE_SSTAT_COMPLETED_PASSES_SHIFT: Shift amount to get the number + * of completed passes if the most recent + * sanitize operation was an Overwrite. This + * value shall be cleared to 0h if the most + * recent sanitize operation was not + * an Overwrite. + * @NVME_SANITIZE_SSTAT_COMPLETED_PASSES_MASK: Mask to get the number of completed + * passes. + * @NVME_SANITIZE_SSTAT_GLOBAL_DATA_ERASED_SHIFT: Shift amount to get the Global + * Data Erased value from the + * &struct nvme_sanitize_log_page.sstat field. + * @NVME_SANITIZE_SSTAT_GLOBAL_DATA_ERASED_MASK: Mask to get the Global Data Erased + * value. + * @NVME_SANITIZE_SSTAT_GLOBAL_DATA_ERASED: Global Data Erased: if set, then no + * namespace user data in the NVM subsystem + * has been written to and no Persistent + * Memory Region in the NVM subsystem has + * been enabled since being manufactured and + * the NVM subsystem has never been sanitized; + * or since the most recent successful sanitize + * operation. + */ +enum nvme_sanitize_sstat { + NVME_SANITIZE_SSTAT_STATUS_SHIFT = 0, + NVME_SANITIZE_SSTAT_STATUS_MASK = 0x7, + NVME_SANITIZE_SSTAT_STATUS_NEVER_SANITIZED = 0, + NVME_SANITIZE_SSTAT_STATUS_COMPLETE_SUCCESS = 1, + NVME_SANITIZE_SSTAT_STATUS_IN_PROGESS = 2, + NVME_SANITIZE_SSTAT_STATUS_COMPLETED_FAILED = 3, + NVME_SANITIZE_SSTAT_STATUS_ND_COMPLETE_SUCCESS = 4, + NVME_SANITIZE_SSTAT_COMPLETED_PASSES_SHIFT = 3, + NVME_SANITIZE_SSTAT_COMPLETED_PASSES_MASK = 0x1f, + NVME_SANITIZE_SSTAT_GLOBAL_DATA_ERASED_SHIFT = 8, + NVME_SANITIZE_SSTAT_GLOBAL_DATA_ERASED_MASK = 0x1, + NVME_SANITIZE_SSTAT_GLOBAL_DATA_ERASED = 1 << NVME_SANITIZE_SSTAT_GLOBAL_DATA_ERASED_SHIFT, +}; + +/** + * struct nvme_zns_changed_zone_log - ZNS Changed Zone List log + * @nrzid: Number of Zone Identifiers + * @rsvd2: Reserved + * @zid: Zone Identifier + */ +struct nvme_zns_changed_zone_log { + __le16 nrzid; + __u8 rsvd2[6]; + __le64 zid[NVME_ZNS_CHANGED_ZONES_MAX]; +}; + +/** + * enum nvme_zns_zt - + * @NVME_ZONE_TYPE_SEQWRITE_REQ: + */ +enum nvme_zns_zt { + NVME_ZONE_TYPE_SEQWRITE_REQ = 0x2, +}; + +/** + * enum nvme_zns_za - + * @NVME_ZNS_ZA_ZFC: Zone Finished by Controller + * @NVME_ZNS_ZA_FZR: Finish Zone Recommended + * @NVME_ZNS_ZA_RZR: Reset Zone Recommended + * @NVME_ZNS_ZA_ZRWAV: + * @NVME_ZNS_ZA_ZDEV: Zone Descriptor Extension Valid + */ +enum nvme_zns_za { + NVME_ZNS_ZA_ZFC = 1 << 0, + NVME_ZNS_ZA_FZR = 1 << 1, + NVME_ZNS_ZA_RZR = 1 << 2, + NVME_ZNS_ZA_ZRWAV = 1 << 3, + NVME_ZNS_ZA_ZDEV = 1 << 7, +}; + +/** + * enum nvme_zns_zs - + * @NVME_ZNS_ZS_EMPTY: Empty state + * @NVME_ZNS_ZS_IMPL_OPEN: Implicitly open state + * @NVME_ZNS_ZS_EXPL_OPEN: Explicitly open state + * @NVME_ZNS_ZS_CLOSED: Closed state + * @NVME_ZNS_ZS_READ_ONLY: Read only state + * @NVME_ZNS_ZS_FULL: Full state + * @NVME_ZNS_ZS_OFFLINE: Offline state + */ +enum nvme_zns_zs { + NVME_ZNS_ZS_EMPTY = 0x1, + NVME_ZNS_ZS_IMPL_OPEN = 0x2, + NVME_ZNS_ZS_EXPL_OPEN = 0x3, + NVME_ZNS_ZS_CLOSED = 0x4, + NVME_ZNS_ZS_READ_ONLY = 0xd, + NVME_ZNS_ZS_FULL = 0xe, + NVME_ZNS_ZS_OFFLINE = 0xf, +}; + +/** + * struct nvme_zns_desc - + * @zt: Zone Type + * @zs: Zone State + * @za: Zone Attributes + * @zai: Zone Attributes Information + * @rsvd4: Reserved + * @zcap: Zone Capacity + * @zslba: Zone Start Logical Block Address + * @wp: Write Pointer + * @rsvd32: Reserved + */ +struct nvme_zns_desc { + __u8 zt; + __u8 zs; + __u8 za; + __u8 zai; + __u8 rsvd4[4]; + __le64 zcap; + __le64 zslba; + __le64 wp; + __u8 rsvd32[32]; +}; + +/** + * struct nvme_zone_report - + * @nr_zones: Number of descriptors in @entries + * @rsvd8: Reserved + * @entries: Zoned namespace descriptors + */ +struct nvme_zone_report { + __le64 nr_zones; + __u8 rsvd8[56]; + struct nvme_zns_desc entries[]; +}; + +/** + * struct nvme_lba_status_desc - + * @dslba: Descriptor Starting LBA + * @nlb: Number of Logical Blocks + * @rsvd12: Reserved + * @status: Additional status about this LBA range + * @rsvd14: Reserved + */ +struct nvme_lba_status_desc { + __le64 dslba; + __le32 nlb; + __u8 rsvd12; + __u8 status; + __u8 rsvd14[2]; +}; + +/** + * struct nvme_lba_status - + * @nlsd: Number of LBA Status Descriptors + * @cmpc: Completion Condition + * @rsvd5: Reserved + * @descs: LBA status descriptor Entry + */ +struct nvme_lba_status { + __le32 nlsd; + __u8 cmpc; + __u8 rsvd5[3]; + struct nvme_lba_status_desc descs[]; +}; + +/** + * struct nvme_feat_auto_pst - + * @apst_entry: See &enum nvme_apst_entry + */ +struct nvme_feat_auto_pst { + __le64 apst_entry[32]; +}; + +/** + * enum nvme_apst_entry - + * @NVME_APST_ENTRY_ITPS_SHIFT: + * @NVME_APST_ENTRY_ITPT_SHIFT: + * @NVME_APST_ENTRY_ITPS_MASK: + * @NVME_APST_ENTRY_ITPT_MASK: + */ +enum nvme_apst_entry { + NVME_APST_ENTRY_ITPS_SHIFT = 3, + NVME_APST_ENTRY_ITPT_SHIFT = 8, + NVME_APST_ENTRY_ITPS_MASK = 0x1f, + NVME_APST_ENTRY_ITPT_MASK = 0xffffff, +}; + +/** + * struct nvme_metadata_element_desc - Metadata Element Descriptor + * @type: Element Type (ET) + * @rev: Element Revision (ER) + * @len: Element Length (ELEN) + * @val: Element Value (EVAL), UTF-8 string + */ +struct nvme_metadata_element_desc { + __u8 type; + __u8 rev; + __u16 len; + __u8 val[0]; +}; + +/** + * struct nvme_host_metadata - Host Metadata Data Structure + * @ndesc: Number of metadata element descriptors + * @rsvd1: Reserved + * @descs: Metadata element descriptors + * @descs_buf: Metadata element descriptor buffer + */ +struct nvme_host_metadata { + __u8 ndesc; + __u8 rsvd1; + union { + struct nvme_metadata_element_desc descs[0]; + __u8 descs_buf[4094]; + }; +}; + +/** + * enum nvme_ctrl_metadata_type - Controller Metadata Element Types + * @NVME_CTRL_METADATA_OS_CTRL_NAME: Name of the controller in + * the operating system. + * @NVME_CTRL_METADATA_OS_DRIVER_NAME: Name of the driver in the + * operating system. + * @NVME_CTRL_METADATA_OS_DRIVER_VER: Version of the driver in + * the operating system. + * @NVME_CTRL_METADATA_PRE_BOOT_CTRL_NAME: Name of the controller in + * the pre-boot environment. + * @NVME_CTRL_METADATA_PRE_BOOT_DRIVER_NAME: Name of the driver in the + * pre-boot environment. + * @NVME_CTRL_METADATA_PRE_BOOT_DRIVER_VER: Version of the driver in the + * pre-boot environment. + * @NVME_CTRL_METADATA_SYS_PROC_MODEL: Model of the processor. + * @NVME_CTRL_METADATA_CHIPSET_DRV_NAME: Chipset driver name. + * @NVME_CTRL_METADATA_CHIPSET_DRV_VERSION: Chipsset driver version. + * @NVME_CTRL_METADATA_OS_NAME_AND_BUILD: Operating system name and build. + * @NVME_CTRL_METADATA_SYS_PROD_NAME: System product name. + * @NVME_CTRL_METADATA_FIRMWARE_VERSION: Host firmware (e.g UEFI) version. + * @NVME_CTRL_METADATA_OS_DRIVER_FILENAME: Operating system driver filename. + * @NVME_CTRL_METADATA_DISPLAY_DRV_NAME: Display driver name. + * @NVME_CTRL_METADATA_DISPLAY_DRV_VERSION: Display driver version. + * @NVME_CTRL_METADATA_HOST_DET_FAIL_REC: Failure record. + */ +enum nvme_ctrl_metadata_type { + NVME_CTRL_METADATA_OS_CTRL_NAME = 0x01, + NVME_CTRL_METADATA_OS_DRIVER_NAME = 0x02, + NVME_CTRL_METADATA_OS_DRIVER_VER = 0x03, + NVME_CTRL_METADATA_PRE_BOOT_CTRL_NAME = 0x04, + NVME_CTRL_METADATA_PRE_BOOT_DRIVER_NAME = 0x05, + NVME_CTRL_METADATA_PRE_BOOT_DRIVER_VER = 0x06, + NVME_CTRL_METADATA_SYS_PROC_MODEL = 0x07, + NVME_CTRL_METADATA_CHIPSET_DRV_NAME = 0x08, + NVME_CTRL_METADATA_CHIPSET_DRV_VERSION = 0x09, + NVME_CTRL_METADATA_OS_NAME_AND_BUILD = 0x0a, + NVME_CTRL_METADATA_SYS_PROD_NAME = 0x0b, + NVME_CTRL_METADATA_FIRMWARE_VERSION = 0x0c, + NVME_CTRL_METADATA_OS_DRIVER_FILENAME = 0x0d, + NVME_CTRL_METADATA_DISPLAY_DRV_NAME = 0x0e, + NVME_CTRL_METADATA_DISPLAY_DRV_VERSION = 0x0f, + NVME_CTRL_METADATA_HOST_DET_FAIL_REC = 0x10, +}; + +/** + * enum nvme_ns_metadata_type - Namespace Metadata Element Types + * @NVME_NS_METADATA_OS_NS_NAME: Name of the namespace in the the + * operating system + * @NVME_NS_METADATA_PRE_BOOT_NS_NAME: Name of the namespace in the pre-boot + * environment. + * @NVME_NS_METADATA_OS_NS_QUAL_1: First qualifier of the Operating System + * Namespace Name. + * @NVME_NS_METADATA_OS_NS_QUAL_2: Second qualifier of the Operating System + * Namespace Name. + */ +enum nvme_ns_metadata_type { + NVME_NS_METADATA_OS_NS_NAME = 0x01, + NVME_NS_METADATA_PRE_BOOT_NS_NAME = 0x02, + NVME_NS_METADATA_OS_NS_QUAL_1 = 0x03, + NVME_NS_METADATA_OS_NS_QUAL_2 = 0x04, +}; + +/** + * struct nvme_timestamp - + * @timestamp: Timestamp value based on origin and synch field + * @attr: Attribute + * @rsvd: Reserved + */ +struct nvme_timestamp { + __u8 timestamp[6]; + __u8 attr; + __u8 rsvd; +}; + +/** + * struct nvme_lba_range_type_entry - + * @type: Specifies the Type of the LBA range + * @attributes: Specifies attributes of the LBA range + * @rsvd2: Reserved + * @slba: Starting LBA + * @nlb: Number of Logical Blocks + * @guid: Unique Identifier + * @rsvd48: Reserved + */ +struct nvme_lba_range_type_entry { + __u8 type; + __u8 attributes; + __u8 rsvd2[14]; + __u64 slba; + __u64 nlb; + __u8 guid[16]; + __u8 rsvd48[16]; +}; + +/** + * enum nvme_lbart - + * @NVME_LBART_TYPE_GP: General Purpose + * @NVME_LBART_TYPE_FS: Filesystem + * @NVME_LBART_TYPE_RAID: RAID + * @NVME_LBART_TYPE_CACHE: Cache + * @NVME_LBART_TYPE_SWAP: Page / swap file + * @NVME_LBART_ATTRIB_TEMP: Temp + * @NVME_LBART_ATTRIB_HIDE: Hidden + */ +enum nvme_lbart { + NVME_LBART_TYPE_GP = 0, + NVME_LBART_TYPE_FS = 1, + NVME_LBART_TYPE_RAID = 2, + NVME_LBART_TYPE_CACHE = 3, + NVME_LBART_TYPE_SWAP = 4, + NVME_LBART_ATTRIB_TEMP = 1 << 0, + NVME_LBART_ATTRIB_HIDE = 1 << 1, +}; + +/** + * struct nvme_lba_range_type - + * @entry: LBA range type entry + */ +struct nvme_lba_range_type { + struct nvme_lba_range_type_entry entry[NVME_FEAT_LBA_RANGE_MAX]; +}; + +/** + * struct nvme_plm_config - + * @ee: Enable Event + * @rsvd2: Reserved + * @dtwinrt: DTWIN Reads Threshold + * @dtwinwt: DTWIN Writes Threshold + * @dtwintt: DTWIN Time Threshold + * @rsvd56: Reserved + */ +struct nvme_plm_config { + __le16 ee; + __u8 rsvd2[30]; + __le64 dtwinrt; + __le64 dtwinwt; + __le64 dtwintt; + __u8 rsvd56[456]; +}; + +/** + * struct nvme_feat_host_behavior - + * @acre: Advanced Command Retry Enable + * @rsvd1: Reserved + */ +struct nvme_feat_host_behavior { + __u8 acre; + __u8 rsvd1[511]; +}; + +/** + * enum nvme_host_behavior_support - + * @NVME_ENABLE_ACRE: Enable Advanced Command Retry Enable + */ +enum nvme_host_behavior_support { + NVME_ENABLE_ACRE = 1 << 0, +}; + +/** + * struct nvme_dsm_range - + * @cattr: Context Attributes + * @nlb: Length in logical blocks + * @slba: Starting LBA + */ +struct nvme_dsm_range { + __le32 cattr; + __le32 nlb; + __le64 slba; +}; + +/** + * struct nvme_copy_range - + * @rsvd0: Reserved + * @slba: Starting LBA + * @nlb: Number of Logical Blocks + * @rsvd18: Reserved + * @eilbrt: Expected Initial Logical Block Reference Tag + * @elbatm: Expected Logical Block Application Tag Mask + * @elbat: Expected Logical Block Application Tag + */ +struct nvme_copy_range { + __u8 rsvd0[8]; + __le64 slba; + __le16 nlb; + __u8 rsvd18[6]; + __le32 eilbrt; + __le16 elbatm; + __le16 elbat; +}; + +/** + * struct nvme_registered_ctrl - + * @cntlid: Controller ID + * @rcsts: Reservation Status + * @rsvd3: Reserved + * @hostid: Host Identifier + * @rkey: Reservation Key + */ +struct nvme_registered_ctrl { + __le16 cntlid; + __u8 rcsts; + __u8 rsvd3[5]; + __le64 hostid; + __le64 rkey; +}; + +/** + * struct nvme_registered_ctrl_ext - + * @cntlid: Controller ID + * @rcsts: Reservation Status + * @rsvd3: Reserved + * @rkey: Reservation Key + * @hostid: Host Identifier + * @rsvd32: Reserved + */ +struct nvme_registered_ctrl_ext { + __le16 cntlid; + __u8 rcsts; + __u8 rsvd3[5]; + __le64 rkey; + __u8 hostid[16]; + __u8 rsvd32[32]; +}; + +/** + * struct nvme_resv_status - + * @gen: Generation + * @rtype: Reservation Type + * @regctl: Number of Registered Controllers + * @rsvd7: Reserved + * @ptpls: Persist Through Power Loss State + * @rsvd10: Reserved + * @rsvd24: Reserved + * @regctl_eds: Registered Controller Extended Data Structure + * @regctl_ds: Registered Controller Data Structure + */ +struct nvme_resv_status { + __le32 gen; + __u8 rtype; + __u8 regctl[2]; + __u8 rsvd7[2]; + __u8 ptpls; + __u8 rsvd10[14]; + union { + struct { + __u8 rsvd24[40]; + struct nvme_registered_ctrl_ext regctl_eds[0]; + }; + struct nvme_registered_ctrl regctl_ds[0]; + }; +}; + +/** + * struct nvme_streams_directive_params - + * @msl: Max Streams Limit + * @nssa: NVM Subsystem Streams Available + * @nsso: NVM Subsystem Streams Open + * @nssc: NVM Subsystem Stream Capability + * @rsvd: Reserved + * @sws: Stream Write Size + * @sgs: Stream Granularity Size + * @nsa: Namespace Streams Allocated + * @nso: Namespace Streams Open + * @rsvd2: Reserved + */ +struct nvme_streams_directive_params { + __le16 msl; + __le16 nssa; + __le16 nsso; + __u8 nssc; + __u8 rsvd[9]; + __le32 sws; + __le16 sgs; + __le16 nsa; + __le16 nso; + __u8 rsvd2[6]; +}; + +/** + * struct nvme_streams_directive_status - + * @osc: Open Stream Count + * @sid: Stream Identifier + */ +struct nvme_streams_directive_status { + __le16 osc; + __le16 sid[]; +}; + +/** + * struct nvme_id_directives - + * @supported: Identify directive is supported + * @enabled: Identify directive is Enabled + * @rsvd64: Reserved + */ +struct nvme_id_directives { + __u8 supported[32]; + __u8 enabled[32]; + __u8 rsvd64[4032]; +}; + +/** + * enum nvme_directive_types - + * @NVME_ID_DIR_ID_BIT: Identify directive is supported + * @NVME_ID_DIR_SD_BIT: Streams directive is supported + */ +enum nvme_directive_types { + NVME_ID_DIR_ID_BIT = 0, + NVME_ID_DIR_SD_BIT = 1, +}; + +/** + * struct nvme_host_mem_buf_attrs - + * @hsize: Host Memory Buffer Size + * @hmdlal: Host Memory Descriptor List Lower Address + * @hmdlau: Host Memory Descriptor List Upper Address + * @hmdlec: Host Memory Descriptor List Entry Count + * @rsvd16: Reserved + */ +struct nvme_host_mem_buf_attrs { + __le32 hsize; + __le32 hmdlal; + __le32 hmdlau; + __le32 hmdlec; + __u8 rsvd16[4080]; + +}; + +/** + * enum nvme_ae_type - + * @NVME_AER_ERROR: Error event + * @NVME_AER_SMART: SMART / Health Status event + * @NVME_AER_NOTICE: Notice event + * @NVME_AER_CSS: NVM Command Set Specific events + * @NVME_AER_VS: Vendor Specific event + */ +enum nvme_ae_type { + NVME_AER_ERROR = 0, + NVME_AER_SMART = 1, + NVME_AER_NOTICE = 2, + NVME_AER_CSS = 6, + NVME_AER_VS = 7, +}; + +/** + * enum nvme_ae_info_error - + * @NVME_AER_ERROR_INVALID_DB_REG: Write to Invalid Doorbell Register + * @NVME_AER_ERROR_INVALID_DB_VAL: Invalid Doorbell Write Value + * @NVME_AER_ERROR_DIAG_FAILURE: Diagnostic Failure + * @NVME_AER_ERROR_PERSISTENT_INTERNAL_ERROR: Persistent Internal Error + * @NVME_AER_ERROR_TRANSIENT_INTERNAL_ERROR: Transient Internal Error + * @NVME_AER_ERROR_FW_IMAGE_LOAD_ERROR: Firmware Image Load Error + */ +enum nvme_ae_info_error { + NVME_AER_ERROR_INVALID_DB_REG = 0x00, + NVME_AER_ERROR_INVALID_DB_VAL = 0x01, + NVME_AER_ERROR_DIAG_FAILURE = 0x02, + NVME_AER_ERROR_PERSISTENT_INTERNAL_ERROR = 0x03, + NVME_AER_ERROR_TRANSIENT_INTERNAL_ERROR = 0x04, + NVME_AER_ERROR_FW_IMAGE_LOAD_ERROR = 0x05, +}; + +/** + * enum nvme_ae_info_smart - + * @NVME_AER_SMART_SUBSYSTEM_RELIABILITY: NVM subsystem Reliability + * @NVME_AER_SMART_TEMPERATURE_THRESHOLD: Temperature Threshold + * @NVME_AER_SMART_SPARE_THRESHOLD: Spare Below Threshold + */ +enum nvme_ae_info_smart { + NVME_AER_SMART_SUBSYSTEM_RELIABILITY = 0x00, + NVME_AER_SMART_TEMPERATURE_THRESHOLD = 0x01, + NVME_AER_SMART_SPARE_THRESHOLD = 0x02, +}; + +/** + * enum nvme_ae_info_css_nvm - + * @NVME_AER_CSS_NVM_RESERVATION: Reservation Log Page Available + * @NVME_AER_CSS_NVM_SANITIZE_COMPLETED: Sanitize Operation Completed + * @NVME_AER_CSS_NVM_UNEXPECTED_SANITIZE_DEALLOC: Sanitize Operation Completed + * With Unexpected Deallocation + */ +enum nvme_ae_info_css_nvm { + NVME_AER_CSS_NVM_RESERVATION = 0x00, + NVME_AER_CSS_NVM_SANITIZE_COMPLETED = 0x01, + NVME_AER_CSS_NVM_UNEXPECTED_SANITIZE_DEALLOC = 0x02, +}; + +/** + * enum nvme_ae_info_notice - + * @NVME_AER_NOTICE_NS_CHANGED: Namespace Attribute Changed + * @NVME_AER_NOTICE_FW_ACT_STARTING: Firmware Activation Starting + * @NVME_AER_NOTICE_TELEMETRY: Telemetry Log Changed + * @NVME_AER_NOTICE_ANA: Asymmetric Namespace Access Change + * @NVME_AER_NOTICE_PL_EVENT: Predictable Latency Event Aggregate Log Change + * @NVME_AER_NOTICE_LBA_STATUS_ALERT: LBA Status Information Alert + * @NVME_AER_NOTICE_EG_EVENT: Endurance Group Event Aggregate Log Page Change + * @NVME_AER_NOTICE_DISC_CHANGED: Discovery Log Page Change + */ +enum nvme_ae_info_notice { + NVME_AER_NOTICE_NS_CHANGED = 0x00, + NVME_AER_NOTICE_FW_ACT_STARTING = 0x01, + NVME_AER_NOTICE_TELEMETRY = 0x02, + NVME_AER_NOTICE_ANA = 0x03, + NVME_AER_NOTICE_PL_EVENT = 0x04, + NVME_AER_NOTICE_LBA_STATUS_ALERT = 0x05, + NVME_AER_NOTICE_EG_EVENT = 0x06, + NVME_AER_NOTICE_DISC_CHANGED = 0xf0, +}; + +/** + * enum nvme_subsys_type - Type of the NVM subsystem. + * @NVME_NQN_DISC: Discovery type target subsystem. Describes a referral to another + * Discovery Service composed of Discovery controllers that provide + * additional discovery records. Multiple Referral entries may + * be reported for each Discovery Service (if that Discovery Service + * has multiple NVM subsystem ports or supports multiple protocols). + * @NVME_NQN_NVME: NVME type target subsystem. Describes an NVM subsystem whose + * controllers may have attached namespaces (an NVM subsystem + * that is not composed of Discovery controllers). Multiple NVM + * Subsystem entries may be reported for each NVM subsystem if + * that NVM subsystem has multiple NVM subsystem ports. + * @NVME_NQN_CURR: Current Discovery type target subsystem. Describes this Discovery + * subsystem (the Discovery Service that contains the controller + * processing the Get Log Page command). Multiple Current Discovery + * Subsystem entries may be reported for this Discovery subsystem + * if the current Discovery subsystem has multiple NVM subsystem + * ports. + */ +enum nvme_subsys_type { + NVME_NQN_DISC = 1, + NVME_NQN_NVME = 2, + NVME_NQN_CURR = 3, +}; + +#define NVME_DISC_SUBSYS_NAME "nqn.2014-08.org.nvmexpress.discovery" +#define NVME_RDMA_IP_PORT 4420 +#define NVME_DISC_IP_PORT 8009 + +/* However the max length of a qualified name is another size */ +#define NVMF_NQN_SIZE 223 +#define NVMF_TRSVCID_SIZE 32 + +/** + * enum nvmf_disc_eflags - Discovery Log Page entry flags. + * @NVMF_DISC_EFLAGS_NONE: Indicates that none of the DUPRETINFO or EPCSD + * features are supported. + * @NVMF_DISC_EFLAGS_DUPRETINFO: Duplicate Returned Information (DUPRETINFO): + * Indicates that using the content of this entry + * to access this Discovery Service returns the same + * information that is returned by using the content + * of other entries in this log page that also have + * this flag set. + * @NVMF_DISC_EFLAGS_EPCSD: Explicit Persistent Connection Support for Discovery (EPCSD): + * Indicates that Explicit Persistent Connections are + * supported for the Discovery controller. + * @NVMF_DISC_EFLAGS_BOTH: Indicates that both the DUPRETINFO and EPCSD + * features are supported. + */ +enum nvmf_disc_eflags { + NVMF_DISC_EFLAGS_NONE = 0, + NVMF_DISC_EFLAGS_DUPRETINFO = 1, + NVMF_DISC_EFLAGS_EPCSD = 2, + NVMF_DISC_EFLAGS_BOTH = 3, +}; + +/** + * union nvmf_tsas - Transport Specific Address Subtype + * @common: Common transport specific attributes + * @rdma: RDMA transport specific attribute settings + * @qptype: RDMA QP Service Type (RDMA_QPTYPE): Specifies the type of RDMA + * Queue Pair. See &enum nvmf_rdma_qptype. + * @prtype: RDMA Provider Type (RDMA_PRTYPE): Specifies the type of RDMA + * provider. See &enum nvmf_rdma_prtype. + * @cms: RDMA Connection Management Service (RDMA_CMS): Specifies the type + * of RDMA IP Connection Management Service. See &enum nvmf_rdma_cms. + * @pkey: RDMA_PKEY: Specifies the Partition Key when AF_IB (InfiniBand) + * address family type is used. + * @tcp: TCP transport specific attribute settings + * @sectype: Security Type (SECTYPE): Specifies the type of security used by the + * NVMe/TCP port. If SECTYPE is a value of 0h (No Security), then the + * host shall set up a normal TCP connection. See &enum nvmf_tcp_sectype. + */ +union nvmf_tsas { + char common[NVMF_TSAS_SIZE]; + struct rdma { + __u8 qptype; + __u8 prtype; + __u8 cms; + __u8 rsvd3[5]; + __u16 pkey; + __u8 rsvd10[246]; + } rdma; + struct tcp { + __u8 sectype; + } tcp; +}; + +/** + * struct nvmf_disc_log_entry - Discovery Log Page entry + * @trtype: Transport Type (TRTYPE): Specifies the NVMe Transport type. + * See &enum nvmf_trtype. + * @adrfam: Address Family (ADRFAM): Specifies the address family. + * See &enum nvmf_addr_family. + * @subtype: Subsystem Type (SUBTYPE): Specifies the type of the NVM subsystem + * that is indicated in this entry. See &enum nvme_subsys_type. + * @treq: Transport Requirements (TREQ): Indicates requirements for the NVMe + * Transport. See &enum nvmf_treq. + * @portid: Port ID (PORTID): Specifies a particular NVM subsystem port. + * Different NVMe Transports or address families may utilize the same + * Port ID value (e.g. a Port ID may support both iWARP and RoCE). + * @cntlid: Controller ID (CNTLID): Specifies the controller ID. If the NVM + * subsystem uses a dynamic controller model, then this field shall + * be set to FFFFh. If the NVM subsystem uses a static controller model, + * then this field may be set to a specific controller ID (values 0h + * to FFEFh are valid). If the NVM subsystem uses a static controller + * model and the value indicated is FFFEh, then the host should remember + * the Controller ID returned as part of the Fabrics Connect command + * in order to re-establish an association in the future with the same + * controller. + * @asqsz: Admin Max SQ Size (ASQSZ): Specifies the maximum size of an Admin + * Submission Queue. This applies to all controllers in the NVM + * subsystem. The value shall be a minimum of 32 entries. + * @eflags: Entry Flags (EFLAGS): Indicates additional information related to + * the current entry. See &enum nvmf_disc_eflags. + * @rsvd12: Reserved + * @trsvcid: Transport Service Identifier (TRSVCID): Specifies the NVMe Transport + * service identifier as an ASCII string. The NVMe Transport service + * identifier is specified by the associated NVMe Transport binding + * specification. + * @rsvd64: Reserved + * @subnqn: NVM Subsystem Qualified Name (SUBNQN): NVMe Qualified Name (NQN) + * that uniquely identifies the NVM subsystem. For a subsystem, if that + * Discovery subsystem has a unique NQN (i.e., the NVM Subsystem NVMe + * Qualified Name (SUBNQN) field in that Discovery subsystem's Identify + * Controller data structure contains a unique NQN value), then the + * value returned shall be that unique NQN. If the Discovery subsystem + * does not have a unique NQN, then the value returned shall be the + * well-known Discovery Service NQN (nqn.2014-08.org.nvmexpress.discovery). + * @traddr: Transport Address (TRADDR): Specifies the address of the NVM subsystem + * that may be used for a Connect command as an ASCII string. The + * Address Family field describes the reference for parsing this field. + * @tsas: Transport specific attribute settings + */ +struct nvmf_disc_log_entry { + __u8 trtype; + __u8 adrfam; + __u8 subtype; + __u8 treq; + __le16 portid; + __le16 cntlid; + __le16 asqsz; + __le16 eflags; + __u8 rsvd12[20]; + char trsvcid[NVMF_TRSVCID_SIZE]; + __u8 rsvd64[192]; + char subnqn[NVME_NQN_LENGTH]; + char traddr[NVMF_TRADDR_SIZE]; + union nvmf_tsas tsas; +}; + +/** + * enum nvmf_trtype - Transport Type codes for Discovery Log Page entry TRTYPE field + * @NVMF_TRTYPE_UNSPECIFIED: Not indicated + * @NVMF_TRTYPE_RDMA: RDMA + * @NVMF_TRTYPE_FC: Fibre Channel + * @NVMF_TRTYPE_TCP: TCP + * @NVMF_TRTYPE_LOOP: Intra-host Transport (i.e., loopback), reserved + * for host usage. + * @NVMF_TRTYPE_MAX: Maximum value for &enum nvmf_trtype + */ +enum nvmf_trtype { + NVMF_TRTYPE_UNSPECIFIED = 0, + NVMF_TRTYPE_RDMA = 1, + NVMF_TRTYPE_FC = 2, + NVMF_TRTYPE_TCP = 3, + NVMF_TRTYPE_LOOP = 254, + NVMF_TRTYPE_MAX, +}; + +/** + * enum nvmf_addr_family - Address Family codes for Discovery Log Page entry ADRFAM field + * @NVMF_ADDR_FAMILY_PCI: PCIe + * @NVMF_ADDR_FAMILY_IP4: AF_INET: IPv4 address family. + * @NVMF_ADDR_FAMILY_IP6: AF_INET6: IPv6 address family. + * @NVMF_ADDR_FAMILY_IB: AF_IB: InfiniBand address family. + * @NVMF_ADDR_FAMILY_FC: Fibre Channel address family. + * @NVMF_ADDR_FAMILY_LOOP: Intra-host Transport (i.e., loopback), reserved + * for host usage. + */ +enum nvmf_addr_family { + NVMF_ADDR_FAMILY_PCI = 0, + NVMF_ADDR_FAMILY_IP4 = 1, + NVMF_ADDR_FAMILY_IP6 = 2, + NVMF_ADDR_FAMILY_IB = 3, + NVMF_ADDR_FAMILY_FC = 4, + NVMF_ADDR_FAMILY_LOOP = 254, +}; + +/** + * enum nvmf_treq - Transport Requirements codes for Discovery Log Page entry TREQ field + * @NVMF_TREQ_NOT_SPECIFIED: Not specified + * @NVMF_TREQ_REQUIRED: Required + * @NVMF_TREQ_NOT_REQUIRED: Not Required + * @NVMF_TREQ_DISABLE_SQFLOW: SQ flow control disable supported + */ +enum nvmf_treq { + NVMF_TREQ_NOT_SPECIFIED = 0, + NVMF_TREQ_REQUIRED = 1, + NVMF_TREQ_NOT_REQUIRED = 2, + NVMF_TREQ_DISABLE_SQFLOW = 4, +}; + +/** + * enum nvmf_rdma_qptype - RDMA QP Service Type codes for Discovery Log Page + * entry TSAS RDMA_QPTYPE field + * @NVMF_RDMA_QPTYPE_CONNECTED: Reliable Connected + * @NVMF_RDMA_QPTYPE_DATAGRAM: Reliable Datagram + */ +enum nvmf_rdma_qptype { + NVMF_RDMA_QPTYPE_CONNECTED = 1, + NVMF_RDMA_QPTYPE_DATAGRAM = 2, +}; + +/** + * enum nvmf_rdma_prtype - RDMA Provider Type codes for Discovery Log Page + * entry TSAS RDMA_PRTYPE field + * @NVMF_RDMA_PRTYPE_NOT_SPECIFIED: No Provider Specified + * @NVMF_RDMA_PRTYPE_IB: InfiniBand + * @NVMF_RDMA_PRTYPE_ROCE: InfiniBand RoCE + * @NVMF_RDMA_PRTYPE_ROCEV2: InfiniBand RoCEV2 + * @NVMF_RDMA_PRTYPE_IWARP: iWARP + */ +enum nvmf_rdma_prtype { + NVMF_RDMA_PRTYPE_NOT_SPECIFIED = 1, + NVMF_RDMA_PRTYPE_IB = 2, + NVMF_RDMA_PRTYPE_ROCE = 3, + NVMF_RDMA_PRTYPE_ROCEV2 = 4, + NVMF_RDMA_PRTYPE_IWARP = 5, +}; + +/** + * enum nvmf_rdma_cms - RDMA Connection Management Service Type codes for + * Discovery Log Page entry TSAS RDMA_CMS field + * @NVMF_RDMA_CMS_RDMA_CM: Sockets based endpoint addressing + * + */ +enum nvmf_rdma_cms { + NVMF_RDMA_CMS_RDMA_CM = 1, +}; + +/** + * enum nvmf_tcp_sectype - Transport Specific Address Subtype Definition for + * NVMe/TCP Transport + * @NVMF_TCP_SECTYPE_NONE: No Security + * @NVMF_TCP_SECTYPE_TLS: Transport Layer Security version 1.2 + * @NVMF_TCP_SECTYPE_TLS13: Transport Layer Security version 1.3 or a subsequent + * version. The TLS protocol negotiates the version and + * cipher suite for each TCP connection. + */ +enum nvmf_tcp_sectype { + NVMF_TCP_SECTYPE_NONE = 0, + NVMF_TCP_SECTYPE_TLS = 1, + NVMF_TCP_SECTYPE_TLS13 = 2, +}; + +/** + * struct nvmf_discovery_log - Discovery Log Page (Log Identifier 70h) + * @genctr: Generation Counter (GENCTR): Indicates the version of the discovery + * information, starting at a value of 0h. For each change in the + * Discovery Log Page, this counter is incremented by one. If the value + * of this field is FFFFFFFF_FFFFFFFFh, then the field shall be cleared + * to 0h when incremented (i.e., rolls over to 0h). + * @numrec: Number of Records (NUMREC): Indicates the number of records + * contained in the log. + * @recfmt: Record Format (RECFMT): Specifies the format of the Discovery Log + * Page. If a new format is defined, this value is incremented by one. + * The format of the record specified in this definition shall be 0h. + * @rsvd14: Reserved + * @entries: Discovery Log Page Entries - see &struct nvmf_disc_log_entry. + */ +struct nvmf_discovery_log { + __le64 genctr; + __le64 numrec; + __le16 recfmt; + __u8 rsvd14[1006]; + struct nvmf_disc_log_entry entries[]; +}; + +/* + * Discovery Information Management (DIM) command. This is sent by a + * host to a Discovery Controller (DC) to perform explicit registration. + */ +#define NVMF_ENAME_LEN 256 +#define NVMF_EVER_LEN 64 + +/** + * enum nvmf_dim_tas - Discovery Information Management Task + * @NVMF_DIM_TAS_REGISTER: Register + * @NVMF_DIM_TAS_DEREGISTER: Deregister + * @NVMF_DIM_TAS_UPDATE: Update + */ +enum nvmf_dim_tas { + NVMF_DIM_TAS_REGISTER = 0x00, + NVMF_DIM_TAS_DEREGISTER = 0x01, + NVMF_DIM_TAS_UPDATE = 0x02, +}; + +/** + * enum nvmf_dim_entfmt - Discovery Information Management Entry Format + * @NVMF_DIM_ENTFMT_BASIC: Basic discovery information entry + * @NVMF_DIM_ENTFMT_EXTENDED: Extended discovery information entry + */ +enum nvmf_dim_entfmt +{ + NVMF_DIM_ENTFMT_BASIC = 0x01, + NVMF_DIM_ENTFMT_EXTENDED = 0x02, +}; + +/** + * enum nvmf_dim_etype -Discovery Information Management Entity Type + * @NVMF_DIM_ETYPE_HOST: Host + * @NVMF_DIM_ETYPE_DDC: Direct Discovery controller + * @NVMF_DIM_ETYPE_CDC: Centralized Discovery controller + */ +enum nvmf_dim_etype +{ + NVMF_DIM_ETYPE_HOST = 0x01, + NVMF_DIM_ETYPE_DDC = 0x02, + NVMF_DIM_ETYPE_CDC = 0x03, +}; + +/** + * enum nvmf_exattype - Extended Attribute Type + * @NVMF_EXATTYPE_HOSTID: Host Identifier + * @NVMF_EXATTYPE_SYMNAME: Symblic Name + */ +enum nvmf_exattype +{ + NVMF_EXATTYPE_HOSTID = 0x01, + NVMF_EXATTYPE_SYMNAME = 0x02, +}; + +/** + * struct nvmf_ext_attr - Extended Attribute (EXAT) + * @exattype: Extended Attribute Type (EXATTYPE) - see @enum nvmf_exattype + * @exatlen: Extended Attribute Length (EXATLEN) + * @exatval: Extended Attribute Value (EXATVAL) - size allocated for array + * must be a multiple of 4 bytes + */ +struct nvmf_ext_attr +{ + __le16 exattype; + __le16 exatlen; + __u8 exatval[]; +}; + +/** + * struct nvmf_ext_die - Extended Discovery Information Entry (DIE) + * @trtype: Transport Type (&enum nvmf_trtype) + * @adrfam: Address Family (&enum nvmf_addr_family) + * @subtype: Subsystem Type (&enum nvme_subsys_type) + * @treq: Transport Requirements (&enum nvmf_treq) + * @portid: Port ID + * @cntlid: Controller ID + * @asqsz: Admin Max SQ Size + * @rsvd10: Reserved + * @trsvcid: Transport Service Identifier + * @resv64: Reserved + * @nqn: NVM Qualified Name + * @traddr: Transport Address + * @tsas: Transport Specific Address Subtype (&union nvmf_tsas) + * @tel: Total Entry Length + * @numexat: Number of Extended Attributes + * @resv1030: Reserved + * @exat: Extented Attributes 0 (&struct nvmf_ext_attr) + */ +struct nvmf_ext_die +{ + __u8 trtype; + __u8 adrfam; + __u8 subtype; + __u8 treq; + __le16 portid; + __le16 cntlid; + __le16 asqsz; + __u8 rsvd10[22]; + char trsvcid[NVMF_TRSVCID_SIZE]; + __u8 resv64[192]; + char nqn[NVME_NQN_LENGTH]; + char traddr[NVMF_TRADDR_SIZE]; + union nvmf_tsas tsas; + __le32 tel; + __le16 numexat; + __u8 resv1030[2]; + struct nvmf_ext_attr exat[]; +}; + +/** + * union nvmf_die - Discovery Information Entry (DIE) + * @basic: Basic format (&struct nvmf_disc_log_entry) + * @extended: Extended format (&struct nvmf_ext_die) + * + * Depending on the ENTFMT specified in the DIM, DIEs can be entered + * with the Basic or Extended formats. For Basic format, each entry + * has a fixed length. Therefore, the "basic" field defined below can + * be accessed as a C array. For the Extended format, however, each + * entry is of variable length (TEL). Therefore, the "extended" field + * defined below cannot be accessed as a C array. Instead, the + * "extended" field is akin to a linked-list, where one can "walk" + * through the list. To move to the next entry, one simply adds the + * current entry's length (TEL) to the "walk" pointer. The number of + * entries in the list is specified by NUMENT. Although extended + * entries are of a variable lengths (TEL), TEL is always a mutiple of + * 4 bytes. + */ +union nvmf_die +{ + struct nvmf_disc_log_entry basic[0]; + struct nvmf_ext_die extended; +}; + +/** + * struct nvmf_dim_data - Discovery Information Management (DIM) - Data + * @tdl: Total Data Length + * @rsvd4: Reserved + * @nument: Number of entries + * @entfmt: Entry Format (&enum nvmf_dim_entfmt) + * @etype: Entity Type (&enum nvmf_dim_etype) + * @portlcl: Port Local + * @rsvd21: Reserved + * @ektype: Entry Key Type + * @eid: Entity Identifier (e.g. Host NQN) + * @ename: Entity Name (e.g. hostname) + * @ever: Entity Version (e.g. OS Name/Version) + * @rsvd600: Reserved + * @die: Discovery Information Entry (see @nument above) + */ +struct nvmf_dim_data +{ + __le32 tdl; + __u8 rsvd4[4]; + __le64 nument; + __le16 entfmt; + __le16 etype; + __u8 portlcl; + __u8 rsvd21; + __le16 ektype; + char eid[NVME_NQN_LENGTH]; + char ename[NVMF_ENAME_LEN]; + char ever[NVMF_EVER_LEN]; + __u8 rsvd600[424]; + union nvmf_die die[]; +}; + +/** + * struct nvmf_connect_data - Data payload for the 'connect' command + * @hostid: Host ID of the connecting host + * @cntlid: Requested controller ID + * @rsvd4: Reserved + * @subsysnqn: Subsystem NQN to connect to + * @hostnqn: Host NQN of the connecting host + * @rsvd5: Reserved + */ +struct nvmf_connect_data { + __u8 hostid[16]; + __le16 cntlid; + char rsvd4[238]; + char subsysnqn[NVME_NQN_LENGTH]; + char hostnqn[NVME_NQN_LENGTH]; + char rsvd5[256]; +}; + +/** + * struct nvme_mi_read_nvm_ss_info - + * @nump: Number of Ports + * @mjr: NVMe-MI Major Version Number + * @mnr: NVMe-MI Minor Version Number + * @rsvd3: Reserved + */ +struct nvme_mi_read_nvm_ss_info { + __u8 nump; + __u8 mjr; + __u8 mnr; + __u8 rsvd3[29]; +}; + +/** + * struct nvme_mi_port_pcie - + * @mps: PCIe Maximum Payload Size + * @sls: PCIe Supported Link Speeds Vector + * @cls: PCIe Current Link Speed + * @mlw: PCIe Maximum Link Width + * @nlw: PCIe Negotiated Link Width + * @pn: PCIe Port Number + * @rsvd14: Reserved + */ +struct nvme_mi_port_pcie { + __u8 mps; + __u8 sls; + __u8 cls; + __u8 mlw; + __u8 nlw; + __u8 pn; + __u8 rsvd14[18]; +}; + +/** + * struct nvme_mi_port_smb - + * @vpd_addr: Current VPD SMBus/I2C Address + * @mvpd_freq: Maximum VPD Access SMBus/I2C Frequency + * @mme_addr: Current Management Endpoint SMBus/I2C Address + * @mme_freq: Maximum Management Endpoint SMBus/I2C Frequency + * @nvmebm: NVMe Basic Management + * @rsvd13: Reserved + */ +struct nvme_mi_port_smb { + __u8 vpd_addr; + __u8 mvpd_freq; + __u8 mme_addr; + __u8 mme_freq; + __u8 nvmebm; + __u8 rsvd13[19]; +}; + +/** + * struct nvme_mi_read_port_info - + * @portt: Port Type + * @rsvd1: Reserved + * @mmctptus: Maximum MCTP Transmission Unit Size + * @meb: Management Endpoint Buffer Size + * @pcie: PCIe Port Specific Data + * @smb: SMBus Port Specific Data + */ +struct nvme_mi_read_port_info { + __u8 portt; + __u8 rsvd1; + __le16 mmctptus; + __le32 meb; + union { + struct nvme_mi_port_pcie pcie; + struct nvme_mi_port_smb smb; + }; +}; + +/** + * struct nvme_mi_read_ctrl_info - + * @portid: Port Identifier + * @rsvd1: Reserved + * @prii: PCIe Routing ID Information + * @pri: PCIe Routing ID + * @vid: PCI Vendor ID + * @did: PCI Device ID + * @ssvid: PCI Subsystem Vendor ID + * @ssid: PCI Subsystem Device ID + * @rsvd16: Reserved + */ +struct nvme_mi_read_ctrl_info { + __u8 portid; + __u8 rsvd1[4]; + __u8 prii; + __le16 pri; + __le16 vid; + __le16 did; + __le16 ssvid; + __le16 ssid; + __u8 rsvd16[16]; +}; + +/** + * struct nvme_mi_osc - + * @type: Command Type + * @opc: Opcode + */ +struct nvme_mi_osc { + __u8 type; + __u8 opc; +}; + +/** + * struct nvme_mi_read_sc_list - + * @numcmd: Number of Commands + * @cmds: MEB supported Command Data Structure + */ +struct nvme_mi_read_sc_list { + __le16 numcmd; + struct nvme_mi_osc cmds[]; +}; + +/** + * struct nvme_mi_nvm_ss_health_status - + * @nss: NVM Subsystem Status + * @sw: Smart Warnings + * @ctemp: Composite Temperature + * @pdlu: Percentage Drive Life Used + * @ccs: Composite Controller Status + * @rsvd8: Reserved + */ +struct nvme_mi_nvm_ss_health_status { + __u8 nss; + __u8 sw; + __u8 ctemp; + __u8 pdlu; + __le16 ccs; + __u8 rsvd8[2]; +}; + +/** + * enum nvme_mi_css - + * @NVME_MI_CCS_RDY: Ready + * @NVME_MI_CSS_CFS: Controller Fatal Status + * @NVME_MI_CSS_SHST: Shutdown Status + * @NVME_MI_CSS_NSSRO: NVM Subsystem Reset Occurred + * @NVME_MI_CSS_CECO: Controller Enable Change Occurred + * @NVME_MI_CSS_NAC: Namespace Attribute Changed + * @NVME_MI_CSS_FA: Firmware Activated + * @NVME_MI_CSS_CSTS: Controller Status Change + * @NVME_MI_CSS_CTEMP: Composite Temperature Change + * @NVME_MI_CSS_PDLU: Percentage Used + * @NVME_MI_CSS_SPARE: Available Spare + * @NVME_MI_CSS_CCWARN: Critical Warning + */ +enum nvme_mi_css { + NVME_MI_CCS_RDY = 1 << 0, + NVME_MI_CSS_CFS = 1 << 1, + NVME_MI_CSS_SHST = 1 << 2, + NVME_MI_CSS_NSSRO = 1 << 4, + NVME_MI_CSS_CECO = 1 << 5, + NVME_MI_CSS_NAC = 1 << 6, + NVME_MI_CSS_FA = 1 << 7, + NVME_MI_CSS_CSTS = 1 << 8, + NVME_MI_CSS_CTEMP = 1 << 9, + NVME_MI_CSS_PDLU = 1 << 10, + NVME_MI_CSS_SPARE = 1 << 11, + NVME_MI_CSS_CCWARN = 1 << 12, +}; + +/** + * struct nvme_mi_ctrl_health_status - + * @ctlid: Controller Identifier + * @csts: Controller Status + * @ctemp: Composite Temperature + * @pdlu: Percentage Used + * @spare: Available Spare + * @cwarn: Critical Warning + * @rsvd9: Reserved + */ +struct nvme_mi_ctrl_health_status { + __le16 ctlid; + __le16 csts; + __le16 ctemp; + __u8 pdlu; + __u8 spare; + __u8 cwarn; + __u8 rsvd9[7]; +}; + +/** + * enum nvme_mi_csts - + * @NVME_MI_CSTS_RDY: Ready + * @NVME_MI_CSTS_CFS: Controller Fatal Status + * @NVME_MI_CSTS_SHST: Shutdown Status + * @NVME_MI_CSTS_NSSRO: NVM Subsystem Reset Occurred + * @NVME_MI_CSTS_CECO: Controller Enable Change Occurred + * @NVME_MI_CSTS_NAC: Namespace Attribute Changed + * @NVME_MI_CSTS_FA: Firmware Activated + */ +enum nvme_mi_csts { + NVME_MI_CSTS_RDY = 1 << 0, + NVME_MI_CSTS_CFS = 1 << 1, + NVME_MI_CSTS_SHST = 1 << 2, + NVME_MI_CSTS_NSSRO = 1 << 4, + NVME_MI_CSTS_CECO = 1 << 5, + NVME_MI_CSTS_NAC = 1 << 6, + NVME_MI_CSTS_FA = 1 << 7, +}; + +/** + * enum nvme_mi_cwarn - + * @NVME_MI_CWARN_ST: Spare Threshold + * @NVME_MI_CWARN_TAUT: Temperature Above or Under Threshold + * @NVME_MI_CWARN_RD: Reliability Degraded + * @NVME_MI_CWARN_RO: Read Only + * @NVME_MI_CWARN_VMBF: Volatile Memory Backup Failed + */ +enum nvme_mi_cwarn { + NVME_MI_CWARN_ST = 1 << 0, + NVME_MI_CWARN_TAUT = 1 << 1, + NVME_MI_CWARN_RD = 1 << 2, + NVME_MI_CWARN_RO = 1 << 3, + NVME_MI_CWARN_VMBF = 1 << 4, +}; + +/** + * struct nvme_mi_vpd_mra - + * @nmravn: NVMe MultiRecord Area Version Number + * @ff: Form Factor + * @rsvd7: Reserved + * @i18vpwr: Initial 1.8 V Power Supply Requirements + * @m18vpwr: Maximum 1.8 V Power Supply Requirements + * @i33vpwr: Initial 3.3 V Power Supply Requirements + * @m33vpwr: Maximum 3.3 V Power Supply Requirements + * @rsvd17: Reserved + * @m33vapsr: Maximum 3.3 V aux Power Supply Requirements + * @i5vapsr: Initial 5 V Power Supply Requirements + * @m5vapsr: Maximum 5 V Power Supply Requirements + * @i12vapsr: Initial 12 V Power Supply Requirements + * @m12vapsr: Maximum 12 V Power Supply Requirements + * @mtl: Maximum Thermal Load + * @tnvmcap: Total NVM Capacity + * @rsvd37: Reserved + */ +struct nvme_mi_vpd_mra { + __u8 nmravn; + __u8 ff; + __u8 rsvd7[6]; + __u8 i18vpwr; + __u8 m18vpwr; + __u8 i33vpwr; + __u8 m33vpwr; + __u8 rsvd17; + __u8 m33vapsr; + __u8 i5vapsr; + __u8 m5vapsr; + __u8 i12vapsr; + __u8 m12vapsr; + __u8 mtl; + __u8 tnvmcap[16]; + __u8 rsvd37[27]; +}; + +/** + * struct nvme_mi_vpd_ppmra - + * @nppmravn: NVMe PCIe Port MultiRecord Area Version Number + * @pn: PCIe Port Number + * @ppi: Port Information + * @ls: PCIe Link Speed + * @mlw: PCIe Maximum Link Width + * @mctp: MCTP Support + * @refccap: Ref Clk Capability + * @pi: Port Identifier + * @rsvd13: Reserved + */ +struct nvme_mi_vpd_ppmra { + __u8 nppmravn; + __u8 pn; + __u8 ppi; + __u8 ls; + __u8 mlw; + __u8 mctp; + __u8 refccap; + __u8 pi; + __u8 rsvd13[3]; +}; + +/** + * struct nvme_mi_vpd_telem - + * @type: Type of the Element Descriptor + * @rev: Revision of the Element Descriptor + * @len: Number of bytes in the Element Descriptor + * @data: Type-specific information associated with + * the Element Descriptor + */ +struct nvme_mi_vpd_telem { + __u8 type; + __u8 rev; + __u8 len; + __u8 data[0]; +}; + +/** + * enum nvme_mi_elem - + * @NVME_MI_ELEM_EED: Extended Element Descriptor + * @NVME_MI_ELEM_USCE: Upstream Connector Element Descriptor + * @NVME_MI_ELEM_ECED: Expansion Connector Element Descriptor + * @NVME_MI_ELEM_LED: Label Element Descriptor + * @NVME_MI_ELEM_SMBMED: SMBus/I2C Mux Element Descriptor + * @NVME_MI_ELEM_PCIESED: PCIe Switch Element Descriptor + * @NVME_MI_ELEM_NVMED: NVM Subsystem Element Descriptor + */ +enum nvme_mi_elem { + NVME_MI_ELEM_EED = 1, + NVME_MI_ELEM_USCE = 2, + NVME_MI_ELEM_ECED = 3, + NVME_MI_ELEM_LED = 4, + NVME_MI_ELEM_SMBMED = 5, + NVME_MI_ELEM_PCIESED = 6, + NVME_MI_ELEM_NVMED = 7, +}; + +/** + * struct nvme_mi_vpd_tra - + * @vn: Version Number + * @rsvd6: Reserved + * @ec: Element Count + * @elems: Element Descriptor + */ +struct nvme_mi_vpd_tra { + __u8 vn; + __u8 rsvd6; + __u8 ec; + struct nvme_mi_vpd_telem elems[0]; +}; + +/** + * struct nvme_mi_vpd_mr_common - + * @type: NVMe Record Type ID + * @rf: Record Format + * @rlen: Record Length + * @rchksum: Record Checksum + * @hchksum: Header Checksum + * @nmra: NVMe MultiRecord Area + * @ppmra: NVMe PCIe Port MultiRecord Area + * @tmra: Topology MultiRecord Area + */ +struct nvme_mi_vpd_mr_common { + __u8 type; + __u8 rf; + __u8 rlen; + __u8 rchksum; + __u8 hchksum; + + union { + struct nvme_mi_vpd_mra nmra; + struct nvme_mi_vpd_ppmra ppmra; + struct nvme_mi_vpd_tra tmra; + }; +}; + +/** + * struct nvme_mi_vpd_hdr - + * @ipmiver: IPMI Format Version Number + * @iuaoff: Internal Use Area Starting Offset + * @ciaoff: Chassis Info Area Starting Offset + * @biaoff: Board Info Area Starting Offset + * @piaoff: Product Info Area Starting Offset + * @mrioff: MultiRecord Info Area Starting Offset + * @rsvd6: Reserved + * @chchk: Common Header Checksum + * @vpd: Vital Product Data + */ +struct nvme_mi_vpd_hdr { + __u8 ipmiver; + __u8 iuaoff; + __u8 ciaoff; + __u8 biaoff; + __u8 piaoff; + __u8 mrioff; + __u8 rsvd6; + __u8 chchk; + __u8 vpd[]; +}; + +/** + * enum nvme_status_field - Defines all parts of the nvme status field: status + * code, status code type, and additional flags. + * @NVME_SCT_GENERIC: Generic errors applicable to multiple opcodes + * @NVME_SCT_CMD_SPECIFIC: Errors associated to a specific opcode + * @NVME_SCT_MEDIA: Errors associated with media and data integrity + * @NVME_SCT_PATH: Errors associated with the paths connection + * @NVME_SCT_VS: Vendor specific errors + * @NVME_SCT_MASK: Mask to get the value of the Status Code Type + * @NVME_SC_MASK: Mask to get the value of the status code. + * @NVME_SC_SUCCESS: Successful Completion: The command + * completed without error. + * @NVME_SC_INVALID_OPCODE: Invalid Command Opcode: A reserved coded + * value or an unsupported value in the + * command opcode field. + * @NVME_SC_INVALID_FIELD: Invalid Field in Command: A reserved + * coded value or an unsupported value in a + * defined field. + * @NVME_SC_CMDID_CONFLICT: Command ID Conflict: The command + * identifier is already in use. + * @NVME_SC_DATA_XFER_ERROR: Data Transfer Error: Transferring the + * data or metadata associated with a + * command experienced an error. + * @NVME_SC_POWER_LOSS: Commands Aborted due to Power Loss + * Notification: Indicates that the command + * was aborted due to a power loss + * notification. + * @NVME_SC_INTERNAL: Internal Error: The command was not + * completed successfully due to an internal error. + * @NVME_SC_ABORT_REQ: Command Abort Requested: The command was + * aborted due to an Abort command being + * received that specified the Submission + * Queue Identifier and Command Identifier + * of this command. + * @NVME_SC_ABORT_QUEUE: Command Aborted due to SQ Deletion: The + * command was aborted due to a Delete I/O + * Submission Queue request received for the + * Submission Queue to which the command was + * submitted. + * @NVME_SC_FUSED_FAIL: Command Aborted due to Failed Fused Command: + * The command was aborted due to the other + * command in a fused operation failing. + * @NVME_SC_FUSED_MISSING: Aborted due to Missing Fused Command: The + * fused command was aborted due to the + * adjacent submission queue entry not + * containing a fused command that is the + * other command. + * @NVME_SC_INVALID_NS: Invalid Namespace or Format: The + * namespace or the format of that namespace + * is invalid. + * @NVME_SC_CMD_SEQ_ERROR: Command Sequence Error: The command was + * aborted due to a protocol violation in a + * multi-command sequence. + * @NVME_SC_SGL_INVALID_LAST: Invalid SGL Segment Descriptor: The + * command includes an invalid SGL Last + * Segment or SGL Segment descriptor. + * @NVME_SC_SGL_INVALID_COUNT: Invalid Number of SGL Descriptors: There + * is an SGL Last Segment descriptor or an + * SGL Segment descriptor in a location + * other than the last descriptor of a + * segment based on the length indicated. + * @NVME_SC_SGL_INVALID_DATA: Data SGL Length Invalid: This may occur + * if the length of a Data SGL is too short. + * This may occur if the length of a Data + * SGL is too long and the controller does + * not support SGL transfers longer than the + * amount of data to be transferred as + * indicated in the SGL Support field of the + * Identify Controller data structure. + * @NVME_SC_SGL_INVALID_METADATA: Metadata SGL Length Invalid: This may + * occur if the length of a Metadata SGL is + * too short. This may occur if the length + * of a Metadata SGL is too long and the + * controller does not support SGL transfers + * longer than the amount of data to be + * transferred as indicated in the SGL + * Support field of the Identify Controller + * data structure. + * @NVME_SC_SGL_INVALID_TYPE: SGL Descriptor Type Invalid: The type of + * an SGL Descriptor is a type that is not + * supported by the controller. + * @NVME_SC_CMB_INVALID_USE: Invalid Use of Controller Memory Buffer: + * The attempted use of the Controller + * Memory Buffer is not supported by the + * controller. + * @NVME_SC_PRP_INVALID_OFFSET: PRP Offset Invalid: The Offset field for + * a PRP entry is invalid. + * @NVME_SC_AWU_EXCEEDED: Atomic Write Unit Exceeded: The length + * specified exceeds the atomic write unit size. + * @NVME_SC_OP_DENIED: Operation Denied: The command was denied + * due to lack of access rights. Refer to + * the appropriate security specification. + * @NVME_SC_SGL_INVALID_OFFSET: SGL Offset Invalid: The offset specified + * in a descriptor is invalid. This may + * occur when using capsules for data + * transfers in NVMe over Fabrics + * implementations and an invalid offset in + * the capsule is specified. + * @NVME_SC_HOSTID_FORMAT: Host Identifier Inconsistent Format: The + * NVM subsystem detected the simultaneous + * use of 64- bit and 128-bit Host + * Identifier values on different + * controllers. + * @NVME_SC_KAT_EXPIRED: Keep Alive Timer Expired: The Keep Alive + * Timer expired. + * @NVME_SC_KAT_INVALID: Keep Alive Timeout Invalid: The Keep + * Alive Timeout value specified is invalid. + * @NVME_SC_CMD_ABORTED_PREMEPT: Command Aborted due to Preempt and Abort: + * The command was aborted due to a + * Reservation Acquire command. + * @NVME_SC_SANITIZE_FAILED: Sanitize Failed: The most recent sanitize + * operation failed and no recovery action + * has been successfully completed. + * @NVME_SC_SANITIZE_IN_PROGRESS: Sanitize In Progress: The requested + * function (e.g., command) is prohibited + * while a sanitize operation is in + * progress. + * @NVME_SC_SGL_INVALID_GRANULARITY: SGL Data Block Granularity Invalid: The + * Address alignment or Length granularity + * for an SGL Data Block descriptor is + * invalid. + * @NVME_SC_CMD_IN_CMBQ_NOT_SUPP: Command Not Supported for Queue in CMB: + * The implementation does not support + * submission of the command to a Submission + * Queue in the Controller Memory Buffer or + * command completion to a Completion Queue + * in the Controller Memory Buffer. + * @NVME_SC_NS_WRITE_PROTECTED: Namespace is Write Protected: The command + * is prohibited while the namespace is + * write protected as a result of a change + * in the namespace write protection state + * as defined by the Namespace Write + * Protection State Machine. + * @NVME_SC_CMD_INTERRUPTED: Command Interrupted: Command processing + * was interrupted and the controller is + * unable to successfully complete the + * command. The host should retry the + * command. + * @NVME_SC_TRAN_TPORT_ERROR: Transient Transport Error: A transient + * transport error was detected. If the + * command is retried on the same + * controller, the command is likely to + * succeed. A command that fails with a + * transient transport error four or more + * times should be treated as a persistent + * transport error that is not likely to + * succeed if retried on the same + * controller. + * @NVME_SC_PROHIBITED_BY_CMD_AND_FEAT: Command Prohibited by Command and Feature + * Lockdown: The command was aborted due to + * command execution being prohibited by + * the Command and Feature Lockdown. + * @NVME_SC_ADMIN_CMD_MEDIA_NOT_READY: Admin Command Media Not Ready: The Admin + * command requires access to media and + * the media is not ready. + * @NVME_SC_LBA_RANGE: LBA Out of Range: The command references + * an LBA that exceeds the size of the namespace. + * @NVME_SC_CAP_EXCEEDED: Capacity Exceeded: Execution of the + * command has caused the capacity of the + * namespace to be exceeded. + * @NVME_SC_NS_NOT_READY: Namespace Not Ready: The namespace is not + * ready to be accessed as a result of a + * condition other than a condition that is + * reported as an Asymmetric Namespace + * Access condition. + * @NVME_SC_RESERVATION_CONFLICT: Reservation Conflict: The command was + * aborted due to a conflict with a + * reservation held on the accessed + * namespace. + * @NVME_SC_FORMAT_IN_PROGRESS: Format In Progress: A Format NVM command + * is in progress on the namespace. + * @NVME_SC_CQ_INVALID: Completion Queue Invalid: The Completion + * Queue identifier specified in the command + * does not exist. + * @NVME_SC_QID_INVALID: Invalid Queue Identifier: The creation of + * the I/O Completion Queue failed due to an + * invalid queue identifier specified as + * part of the command. An invalid queue + * identifier is one that is currently in + * use or one that is outside the range + * supported by the controller. + * @NVME_SC_QUEUE_SIZE: Invalid Queue Size: The host attempted to + * create an I/O Completion Queue with an + * invalid number of entries. + * @NVME_SC_ABORT_LIMIT: Abort Command Limit Exceeded: The number + * of concurrently outstanding Abort commands + * has exceeded the limit indicated in the + * Identify Controller data structure. + * @NVME_SC_ABORT_MISSING: Abort Command is missing: The abort + * command is missing. + * @NVME_SC_ASYNC_LIMIT: Asynchronous Event Request Limit + * Exceeded: The number of concurrently + * outstanding Asynchronous Event Request + * commands has been exceeded. + * @NVME_SC_FIRMWARE_SLOT: Invalid Firmware Slot: The firmware slot + * indicated is invalid or read only. This + * error is indicated if the firmware slot + * exceeds the number supported. + * @NVME_SC_FIRMWARE_IMAGE: Invalid Firmware Image: The firmware + * image specified for activation is invalid + * and not loaded by the controller. + * @NVME_SC_INVALID_VECTOR: Invalid Interrupt Vector: The creation of + * the I/O Completion Queue failed due to an + * invalid interrupt vector specified as + * part of the command. + * @NVME_SC_INVALID_LOG_PAGE: Invalid Log Page: The log page indicated + * is invalid. This error condition is also + * returned if a reserved log page is + * requested. + * @NVME_SC_INVALID_FORMAT: Invalid Format: The LBA Format specified + * is not supported. + * @NVME_SC_FW_NEEDS_CONV_RESET: Firmware Activation Requires Conventional Reset: + * The firmware commit was successful, + * however, activation of the firmware image + * requires a conventional reset. + * @NVME_SC_INVALID_QUEUE: Invalid Queue Deletion: Invalid I/O + * Completion Queue specified to delete. + * @NVME_SC_FEATURE_NOT_SAVEABLE: Feature Identifier Not Saveable: The + * Feature Identifier specified does not + * support a saveable value. + * @NVME_SC_FEATURE_NOT_CHANGEABLE: Feature Not Changeable: The Feature + * Identifier is not able to be changed. + * @NVME_SC_FEATURE_NOT_PER_NS: Feature Not Namespace Specific: The + * Feature Identifier specified is not + * namespace specific. The Feature + * Identifier settings apply across all + * namespaces. + * @NVME_SC_FW_NEEDS_SUBSYS_RESET: Firmware Activation Requires NVM + * Subsystem Reset: The firmware commit was + * successful, however, activation of the + * firmware image requires an NVM Subsystem. + * @NVME_SC_FW_NEEDS_RESET: Firmware Activation Requires Controller + * Level Reset: The firmware commit was + * successful; however, the image specified + * does not support being activated without + * a reset. + * @NVME_SC_FW_NEEDS_MAX_TIME: Firmware Activation Requires Maximum Time + * Violation: The image specified if + * activated immediately would exceed the + * Maximum Time for Firmware Activation + * (MTFA) value reported in Identify + * Controller. + * @NVME_SC_FW_ACTIVATE_PROHIBITED: Firmware Activation Prohibited: The image + * specified is being prohibited from + * activation by the controller for vendor + * specific reasons. + * @NVME_SC_OVERLAPPING_RANGE: Overlapping Range: The downloaded + * firmware image has overlapping ranges. + * @NVME_SC_NS_INSUFFICIENT_CAP: Namespace Insufficient Capacity: Creating + * the namespace requires more free space + * than is currently available. + * @NVME_SC_NS_ID_UNAVAILABLE: Namespace Identifier Unavailable: The + * number of namespaces supported has been + * exceeded. + * @NVME_SC_NS_ALREADY_ATTACHED: Namespace Already Attached: The + * controller is already attached to the + * namespace specified. + * @NVME_SC_NS_IS_PRIVATE: Namespace Is Private: The namespace is + * private and is already attached to one + * controller. + * @NVME_SC_NS_NOT_ATTACHED: Namespace Not Attached: The request to + * detach the controller could not be + * completed because the controller is not + * attached to the namespace. + * @NVME_SC_THIN_PROV_NOT_SUPP: Thin Provisioning Not Supported: Thin + * provisioning is not supported by the + * controller. + * @NVME_SC_CTRL_LIST_INVALID: Controller List Invalid: The controller + * list provided contains invalid controller + * ids. + * @NVME_SC_SELF_TEST_IN_PROGRESS: Device Self-test In Progress: The controller + * or NVM subsystem already has a device + * self-test operation in process. + * @NVME_SC_BP_WRITE_PROHIBITED: Boot Partition Write Prohibited: The + * command is trying to modify a locked Boot + * Partition. + * @NVME_SC_INVALID_CTRL_ID: Invalid Controller Identifier: + * @NVME_SC_INVALID_SEC_CTRL_STATE: Invalid Secondary Controller State + * @NVME_SC_INVALID_CTRL_RESOURCES: Invalid Number of Controller Resources + * @NVME_SC_INVALID_RESOURCE_ID: Invalid Resource Identifier + * @NVME_SC_PMR_SAN_PROHIBITED: Sanitize Prohibited While Persistent + * Memory Region is Enabled + * @NVME_SC_ANA_GROUP_ID_INVALID: ANA Group Identifier Invalid: The specified + * ANA Group Identifier (ANAGRPID) is not + * supported in the submitted command. + * @NVME_SC_ANA_ATTACH_FAILED: ANA Attach Failed: The controller is not + * attached to the namespace as a result + * of an ANA condition. + * @NVME_SC_INSUFFICIENT_CAP: Insufficient Capacity: Requested operation + * requires more free space than is currently + * available. + * @NVME_SC_NS_ATTACHMENT_LIMIT_EXCEEDED: Namespace Attachment Limit Exceeded: + * Attaching the ns to a controller causes + * max number of ns attachments allowed + * to be exceeded. + * @NVME_SC_PROHIBIT_CMD_EXEC_NOT_SUPPORTED: Prohibition of Command Execution + * Not Supported + * @NVME_SC_IOCS_NOT_SUPPORTED: I/O Command Set Not Supported + * @NVME_SC_IOCS_NOT_ENABLED: I/O Command Set Not Enabled + * @NVME_SC_IOCS_COMBINATION_REJECTED: I/O Command Set Combination Rejected + * @NVME_SC_INVALID_IOCS: Invalid I/O Command Set + * @NVME_SC_ID_UNAVAILABLE: Identifier Unavailable + * @NVME_SC_INVALID_DISCOVERY_INFO: The discovery information provided in + * one or more extended discovery + * information entries is not applicable + * for the type of entity selected in + * the Entity Type (ETYPE) field of the + * Discovery Information Management + * command data portion’s header. + * @NVME_SC_ZONING_DATA_STRUCT_LOCKED:The requested Zoning data structure + * is locked on the CDC. + * @NVME_SC_ZONING_DATA_STRUCT_NOTFND:The requested Zoning data structure + * does not exist on the CDC. + * @NVME_SC_INSUFFICIENT_DISC_RES: The number of discover information + * entries provided in the data portion + * of the Discovery Information + * Management command for a registration + * task (i.e., TAS field cleared to 0h) + * exceeds the available capacity for + * new discovery information entries on + * the CDC or DDC. This may be a + * transient condition. + * @NVME_SC_REQSTD_FUNCTION_DISABLED: Fabric Zoning is not enabled on the + * CDC + * @NVME_SC_ZONEGRP_ORIGINATOR_INVL: The NQN contained in the ZoneGroup + * Originator field does not match the + * Host NQN used by the DDC to connect + * to the CDC. + * @NVME_SC_BAD_ATTRIBUTES: Conflicting Dataset Management Attributes + * @NVME_SC_INVALID_PI: Invalid Protection Information + * @NVME_SC_READ_ONLY: Attempted Write to Read Only Range + * @NVME_SC_CMD_SIZE_LIMIT_EXCEEDED: Command Size Limit Exceeded + * @NVME_SC_CONNECT_FORMAT: Incompatible Format: The NVM subsystem + * does not support the record format + * specified by the host. + * @NVME_SC_CONNECT_CTRL_BUSY: Controller Busy: The controller is + * already associated with a host. + * @NVME_SC_CONNECT_INVALID_PARAM: Connect Invalid Parameters: One or more + * of the command parameters. + * @NVME_SC_CONNECT_RESTART_DISC: Connect Restart Discovery: The NVM + * subsystem requested is not available. + * @NVME_SC_CONNECT_INVALID_HOST: Connect Invalid Host: The host is either + * not allowed to establish an association + * to any controller in the NVM subsystem or + * the host is not allowed to establish an + * association to the specified controller + * @NVME_SC_DISCONNECT_INVALID_QTYPE: Invalid Queue Type: The command was sent + * on the wrong queue type. + * @NVME_SC_DISCOVERY_RESTART: Discover Restart: The snapshot of the + * records is now invalid or out of date. + * @NVME_SC_AUTH_REQUIRED: Authentication Required: NVMe in-band + * authentication is required and the queue + * has not yet been authenticated. + * @NVME_SC_WRITE_FAULT: Write Fault: The write data could not be + * committed to the media. + * @NVME_SC_READ_ERROR: Unrecovered Read Error: The read data + * could not be recovered from the media. + * @NVME_SC_GUARD_CHECK: End-to-end Guard Check Error: The command + * was aborted due to an end-to-end guard + * check failure. + * @NVME_SC_APPTAG_CHECK: End-to-end Application Tag Check Error: + * The command was aborted due to an + * end-to-end application tag check failure. + * @NVME_SC_REFTAG_CHECK: End-to-end Reference Tag Check Error: The + * command was aborted due to an end-to-end + * reference tag check failure. + * @NVME_SC_COMPARE_FAILED: Compare Failure: The command failed due + * to a miscompare during a Compare command. + * @NVME_SC_ACCESS_DENIED: Access Denied: Access to the namespace + * and/or LBA range is denied due to lack of + * access rights. + * @NVME_SC_UNWRITTEN_BLOCK: Deallocated or Unwritten Logical Block: + * The command failed due to an attempt to + * read from or verify an LBA range + * containing a deallocated or unwritten + * logical block. + * @NVME_SC_STORAGE_TAG_CHECK: End-to-End Storage Tag Check Error: The + * command was aborted due to an end-to-end + * storage tag check failure. + * @NVME_SC_ANA_INTERNAL_PATH_ERROR: Internal Path Error: The command was not + * completed as the result of a controller + * internal error that is specific to the + * controller processing the command. + * @NVME_SC_ANA_PERSISTENT_LOSS: Asymmetric Access Persistent Loss: The + * requested function (e.g., command) is not + * able to be performed as a result of the + * relationship between the controller and + * the namespace being in the ANA Persistent + * Loss state. + * @NVME_SC_ANA_INACCESSIBLE: Asymmetric Access Inaccessible: The + * requested function (e.g., command) is not + * able to be performed as a result of the + * relationship between the controller and + * the namespace being in the ANA + * Inaccessible state. + * @NVME_SC_ANA_TRANSITION: Asymmetric Access Transition: The + * requested function (e.g., command) is not + * able to be performed as a result of the + * relationship between the controller and + * the namespace transitioning between + * Asymmetric Namespace Access states. + * @NVME_SC_CTRL_PATH_ERROR: Controller Pathing Error: A pathing error + * was detected by the controller. + * @NVME_SC_HOST_PATH_ERROR: Host Pathing Error: A pathing error was + * detected by the host. + * @NVME_SC_CMD_ABORTED_BY_HOST: Command Aborted By Host: The command was + * aborted as a result of host action. + * @NVME_SC_CRD: Mask to get value of Command Retry Delay + * index + * @NVME_SC_MORE: More bit. If set, more status information + * for this command as part of the Error + * Information log that may be retrieved with + * the Get Log Page command. + * @NVME_SC_DNR: Do Not Retry bit. If set, if the same + * command is re-submitted to any controller + * in the NVM subsystem, then that + * re-submitted command is expected to fail. + * @NVME_SC_ZNS_INVALID_OP_REQUEST: Invalid Zone Operation Request: + * The operation requested is invalid. This may be due to + * various conditions, including: attempting to allocate a + * ZRWA when a zone is not in the ZSE:Empty state; or + * invalid Flush Explicit ZRWA Range Send Zone Action + * operation. + * @NVME_SC_ZNS_ZRWA_RESOURCES_UNAVAILABLE: ZRWA Resources Unavailable: + * No ZRWAs are available. + * @NVME_SC_ZNS_BOUNDARY_ERROR: Zone Boundary Error: The command specifies + * logical blocks in more than one zone. + * @NVME_SC_ZNS_FULL: Zone Is Full: The accessed zone is in the + * ZSF:Full state. + * @NVME_SC_ZNS_READ_ONLY: Zone Is Read Only: The accessed zone is + * in the ZSRO:Read Only state. + * @NVME_SC_ZNS_OFFLINE: Zone Is Offline: The accessed zone is + * in the ZSO:Offline state. + * @NVME_SC_ZNS_INVALID_WRITE: Zone Invalid Write: The write to a zone + * was not at the write pointer. + * @NVME_SC_ZNS_TOO_MANY_ACTIVE: Too Many Active Zones: The controller + * does not allow additional active zones. + * @NVME_SC_ZNS_TOO_MANY_OPENS: Too Many Open Zones: The controller does + * not allow additional open zones. + * @NVME_SC_ZNS_INVAL_TRANSITION: Invalid Zone State Transition: The request + * is not a valid zone state transition. + */ +enum nvme_status_field { + /* + * Status Code Type indicators + */ + NVME_SCT_GENERIC = 0x0, + NVME_SCT_CMD_SPECIFIC = 0x1, + NVME_SCT_MEDIA = 0x2, + NVME_SCT_PATH = 0x3, + NVME_SCT_VS = 0x7, + NVME_SCT_MASK = 0x7, + NVME_SCT_SHIFT = 0x8, + + /* + * Status Code inidicators + */ + NVME_SC_MASK = 0xff, + NVME_SC_SHIFT = 0x0, + + /* + * Generic Command Status Codes: + */ + NVME_SC_SUCCESS = 0x0, + NVME_SC_INVALID_OPCODE = 0x1, + NVME_SC_INVALID_FIELD = 0x2, + NVME_SC_CMDID_CONFLICT = 0x3, + NVME_SC_DATA_XFER_ERROR = 0x4, + NVME_SC_POWER_LOSS = 0x5, + NVME_SC_INTERNAL = 0x6, + NVME_SC_ABORT_REQ = 0x7, + NVME_SC_ABORT_QUEUE = 0x8, + NVME_SC_FUSED_FAIL = 0x9, + NVME_SC_FUSED_MISSING = 0xa, + NVME_SC_INVALID_NS = 0xb, + NVME_SC_CMD_SEQ_ERROR = 0xc, + NVME_SC_SGL_INVALID_LAST = 0xd, + NVME_SC_SGL_INVALID_COUNT = 0xe, + NVME_SC_SGL_INVALID_DATA = 0xf, + NVME_SC_SGL_INVALID_METADATA = 0x10, + NVME_SC_SGL_INVALID_TYPE = 0x11, + NVME_SC_CMB_INVALID_USE = 0x12, + NVME_SC_PRP_INVALID_OFFSET = 0x13, + NVME_SC_AWU_EXCEEDED = 0x14, + NVME_SC_OP_DENIED = 0x15, + NVME_SC_SGL_INVALID_OFFSET = 0x16, + NVME_SC_HOSTID_FORMAT = 0x18, + NVME_SC_KAT_EXPIRED = 0x19, + NVME_SC_KAT_INVALID = 0x1a, + NVME_SC_CMD_ABORTED_PREMEPT = 0x1b, + NVME_SC_SANITIZE_FAILED = 0x1c, + NVME_SC_SANITIZE_IN_PROGRESS = 0x1d, + NVME_SC_SGL_INVALID_GRANULARITY = 0x1e, + NVME_SC_CMD_IN_CMBQ_NOT_SUPP = 0x1f, + NVME_SC_NS_WRITE_PROTECTED = 0x20, + NVME_SC_CMD_INTERRUPTED = 0x21, + NVME_SC_TRAN_TPORT_ERROR = 0x22, + NVME_SC_PROHIBITED_BY_CMD_AND_FEAT = 0x23, + NVME_SC_ADMIN_CMD_MEDIA_NOT_READY = 0x24, + NVME_SC_LBA_RANGE = 0x80, + NVME_SC_CAP_EXCEEDED = 0x81, + NVME_SC_NS_NOT_READY = 0x82, + NVME_SC_RESERVATION_CONFLICT = 0x83, + NVME_SC_FORMAT_IN_PROGRESS = 0x84, + + /* + * Command Specific Status Codes: + */ + NVME_SC_CQ_INVALID = 0x00, + NVME_SC_QID_INVALID = 0x01, + NVME_SC_QUEUE_SIZE = 0x02, + NVME_SC_ABORT_LIMIT = 0x03, + NVME_SC_ABORT_MISSING = 0x04, + NVME_SC_ASYNC_LIMIT = 0x05, + NVME_SC_FIRMWARE_SLOT = 0x06, + NVME_SC_FIRMWARE_IMAGE = 0x07, + NVME_SC_INVALID_VECTOR = 0x08, + NVME_SC_INVALID_LOG_PAGE = 0x09, + NVME_SC_INVALID_FORMAT = 0x0a, + NVME_SC_FW_NEEDS_CONV_RESET = 0x0b, + NVME_SC_INVALID_QUEUE = 0x0c, + NVME_SC_FEATURE_NOT_SAVEABLE = 0x0d, + NVME_SC_FEATURE_NOT_CHANGEABLE = 0x0e, + NVME_SC_FEATURE_NOT_PER_NS = 0x0f, + NVME_SC_FW_NEEDS_SUBSYS_RESET = 0x10, + NVME_SC_FW_NEEDS_RESET = 0x11, + NVME_SC_FW_NEEDS_MAX_TIME = 0x12, + NVME_SC_FW_ACTIVATE_PROHIBITED = 0x13, + NVME_SC_OVERLAPPING_RANGE = 0x14, + NVME_SC_NS_INSUFFICIENT_CAP = 0x15, + NVME_SC_NS_ID_UNAVAILABLE = 0x16, + NVME_SC_NS_ALREADY_ATTACHED = 0x18, + NVME_SC_NS_IS_PRIVATE = 0x19, + NVME_SC_NS_NOT_ATTACHED = 0x1a, + NVME_SC_THIN_PROV_NOT_SUPP = 0x1b, + NVME_SC_CTRL_LIST_INVALID = 0x1c, + NVME_SC_SELF_TEST_IN_PROGRESS = 0x1d, + NVME_SC_BP_WRITE_PROHIBITED = 0x1e, + NVME_SC_INVALID_CTRL_ID = 0x1f, + NVME_SC_INVALID_SEC_CTRL_STATE = 0x20, + NVME_SC_INVALID_CTRL_RESOURCES = 0x21, + NVME_SC_INVALID_RESOURCE_ID = 0x22, + NVME_SC_PMR_SAN_PROHIBITED = 0x23, + NVME_SC_ANA_GROUP_ID_INVALID = 0x24, + NVME_SC_ANA_ATTACH_FAILED = 0x25, + NVME_SC_INSUFFICIENT_CAP = 0x26, + NVME_SC_NS_ATTACHMENT_LIMIT_EXCEEDED = 0x27, + NVME_SC_PROHIBIT_CMD_EXEC_NOT_SUPPORTED = 0x28, + + /* + * Command Set Specific - Namespace Types commands: + */ + NVME_SC_IOCS_NOT_SUPPORTED = 0x29, + NVME_SC_IOCS_NOT_ENABLED = 0x2a, + NVME_SC_IOCS_COMBINATION_REJECTED = 0x2b, + NVME_SC_INVALID_IOCS = 0x2c, + NVME_SC_ID_UNAVAILABLE = 0x2d, + + /* + * Discovery Information Management + */ + NVME_SC_INVALID_DISCOVERY_INFO = 0x2f, + NVME_SC_ZONING_DATA_STRUCT_LOCKED = 0x30, + NVME_SC_ZONING_DATA_STRUCT_NOTFND = 0x31, + NVME_SC_INSUFFICIENT_DISC_RES = 0x32, + NVME_SC_REQSTD_FUNCTION_DISABLED = 0x33, + NVME_SC_ZONEGRP_ORIGINATOR_INVLD = 0x34, + + /* + * I/O Command Set Specific - NVM commands: + */ + NVME_SC_BAD_ATTRIBUTES = 0x80, + NVME_SC_INVALID_PI = 0x81, + NVME_SC_READ_ONLY = 0x82, + NVME_SC_CMD_SIZE_LIMIT_EXCEEDED = 0x83, + + /* + * I/O Command Set Specific - Fabrics commands: + */ + NVME_SC_CONNECT_FORMAT = 0x80, + NVME_SC_CONNECT_CTRL_BUSY = 0x81, + NVME_SC_CONNECT_INVALID_PARAM = 0x82, + NVME_SC_CONNECT_RESTART_DISC = 0x83, + NVME_SC_CONNECT_INVALID_HOST = 0x84, + NVME_SC_DISCONNECT_INVALID_QTYPE= 0x85, + NVME_SC_DISCOVERY_RESTART = 0x90, + NVME_SC_AUTH_REQUIRED = 0x91, + + /* + * I/O Command Set Specific - ZNS commands: + */ + NVME_SC_ZNS_INVALID_OP_REQUEST = 0xb6, + NVME_SC_ZNS_ZRWA_RESOURCES_UNAVAILABLE = 0xb7, + NVME_SC_ZNS_BOUNDARY_ERROR = 0xb8, + NVME_SC_ZNS_FULL = 0xb9, + NVME_SC_ZNS_READ_ONLY = 0xba, + NVME_SC_ZNS_OFFLINE = 0xbb, + NVME_SC_ZNS_INVALID_WRITE = 0xbc, + NVME_SC_ZNS_TOO_MANY_ACTIVE = 0xbd, + NVME_SC_ZNS_TOO_MANY_OPENS = 0xbe, + NVME_SC_ZNS_INVAL_TRANSITION = 0xbf, + + /* + * Media and Data Integrity Errors: + */ + NVME_SC_WRITE_FAULT = 0x80, + NVME_SC_READ_ERROR = 0x81, + NVME_SC_GUARD_CHECK = 0x82, + NVME_SC_APPTAG_CHECK = 0x83, + NVME_SC_REFTAG_CHECK = 0x84, + NVME_SC_COMPARE_FAILED = 0x85, + NVME_SC_ACCESS_DENIED = 0x86, + NVME_SC_UNWRITTEN_BLOCK = 0x87, + NVME_SC_STORAGE_TAG_CHECK = 0x88, + + /* + * Path-related Errors: + */ + NVME_SC_ANA_INTERNAL_PATH_ERROR = 0x00, + NVME_SC_ANA_PERSISTENT_LOSS = 0x01, + NVME_SC_ANA_INACCESSIBLE = 0x02, + NVME_SC_ANA_TRANSITION = 0x03, + NVME_SC_CTRL_PATH_ERROR = 0x60, + NVME_SC_HOST_PATH_ERROR = 0x70, + NVME_SC_CMD_ABORTED_BY_HOST = 0x71, + + /* + * Additional status field flags + */ + NVME_SC_CRD = 0x1800, + NVME_SC_MORE = 0x2000, + NVME_SC_DNR = 0x4000, +}; + +/** + * nvme_status_code_type() - Returns the NVMe Status Code Type + * @status_field: The NVMe Completion Queue Entry's Status Field + * + * See &enum nvme_status_field + */ +static inline __u16 nvme_status_code_type(__u16 status_field) +{ + return NVME_GET(status_field, SCT); +} + +/** + * nvme_status_code() - Returns the NVMe Status Code + * @status_field: The NVMe Completion Queue Entry's Status Field + * + * See &enum nvme_status_field + */ +static inline __u16 nvme_status_code(__u16 status_field) +{ + return NVME_GET(status_field, SC); +} + +/** + * enum nvme_admin_opcode - Known NVMe admin opcodes + * @nvme_admin_delete_sq: Delete I/O Submission Queue + * @nvme_admin_create_sq: Create I/O Submission Queue + * @nvme_admin_get_log_page: Get Log Page + * @nvme_admin_delete_cq: Delete I/O Completion Queue + * @nvme_admin_create_cq: Create I/O Completion Queue + * @nvme_admin_identify: Identify + * @nvme_admin_abort_cmd: Abort + * @nvme_admin_set_features: Set Features + * @nvme_admin_get_features: Get Features + * @nvme_admin_async_event: Asynchronous Event Request + * @nvme_admin_ns_mgmt: Namespace Management + * @nvme_admin_fw_activate: Firmware Commit + * @nvme_admin_fw_commit: Firmware Commit + * @nvme_admin_fw_download: Firmware Image Download + * @nvme_admin_dev_self_test: Device Self-test + * @nvme_admin_ns_attach: Namespace Attachment + * @nvme_admin_keep_alive: Keep Alive + * @nvme_admin_directive_send: Directive Send + * @nvme_admin_directive_recv: Directive Receive + * @nvme_admin_virtual_mgmt: Virtualization Management + * @nvme_admin_nvme_mi_send: NVMe-MI Send + * @nvme_admin_nvme_mi_recv: NVMe-MI Receive + * @nvme_admin_capacity_mgmt: Capacity Management + * @nvme_admin_discovery_info_mgmt: Discovery Information Management (DIM) + * @nvme_admin_fabric_zoning_recv: Fabric Zoning Receive + * @nvme_admin_lockdown: Lockdown + * @nvme_admin_fabric_zoning_lookup: Fabric Zoning Lookup + * @nvme_admin_fabric_zoning_send: Fabric Zoning Send + * @nvme_admin_dbbuf: Doorbell Buffer Config + * @nvme_admin_fabrics: Fabrics Commands + * @nvme_admin_format_nvm: Format NVM + * @nvme_admin_security_send: Security Send + * @nvme_admin_security_recv: Security Receive + * @nvme_admin_sanitize_nvm: Sanitize + * @nvme_admin_get_lba_status: Get LBA Status + */ +enum nvme_admin_opcode { + nvme_admin_delete_sq = 0x00, + nvme_admin_create_sq = 0x01, + nvme_admin_get_log_page = 0x02, + nvme_admin_delete_cq = 0x04, + nvme_admin_create_cq = 0x05, + nvme_admin_identify = 0x06, + nvme_admin_abort_cmd = 0x08, + nvme_admin_set_features = 0x09, + nvme_admin_get_features = 0x0a, + nvme_admin_async_event = 0x0c, + nvme_admin_ns_mgmt = 0x0d, + nvme_admin_fw_commit = 0x10, + nvme_admin_fw_activate = nvme_admin_fw_commit, + nvme_admin_fw_download = 0x11, + nvme_admin_dev_self_test = 0x14, + nvme_admin_ns_attach = 0x15, + nvme_admin_keep_alive = 0x18, + nvme_admin_directive_send = 0x19, + nvme_admin_directive_recv = 0x1a, + nvme_admin_virtual_mgmt = 0x1c, + nvme_admin_nvme_mi_send = 0x1d, + nvme_admin_nvme_mi_recv = 0x1e, + nvme_admin_capacity_mgmt = 0x20, + nvme_admin_discovery_info_mgmt = 0x21, + nvme_admin_fabric_zoning_recv = 0x22, + nvme_admin_lockdown = 0x24, + nvme_admin_fabric_zoning_lookup = 0x25, + nvme_admin_fabric_zoning_send = 0x29, + nvme_admin_dbbuf = 0x7c, + nvme_admin_fabrics = 0x7f, + nvme_admin_format_nvm = 0x80, + nvme_admin_security_send = 0x81, + nvme_admin_security_recv = 0x82, + nvme_admin_sanitize_nvm = 0x84, + nvme_admin_get_lba_status = 0x86, +}; + +/** + * enum nvme_identify_cns - + * @NVME_IDENTIFY_CNS_NS: Identify Namespace data structure + * @NVME_IDENTIFY_CNS_CTRL: Identify Controller data structur + * @NVME_IDENTIFY_CNS_NS_ACTIVE_LIST: Active Namespace ID list + * @NVME_IDENTIFY_CNS_NS_DESC_LIST: Namespace Identification Descriptor list + * @NVME_IDENTIFY_CNS_NVMSET_LIST: NVM Set List + * @NVME_IDENTIFY_CNS_CSI_NS: I/O Command Set specific Identify + * Namespace data structure + * @NVME_IDENTIFY_CNS_CSI_CTRL: I/O Command Set specific Identify + * Controller data structure + * @NVME_IDENTIFY_CNS_CSI_NS_ACTIVE_LIST: Active Namespace ID list associated + * with the specified I/O Command Set + * @NVME_IDENTIFY_CNS_CSI_INDEPENDENT_ID_NS: I/O Command Set Independent Identify + * Namespace data structure + * @NVME_IDENTIFY_CNS_ALLOCATED_NS_LIST: Allocated Namespace ID list + * @NVME_IDENTIFY_CNS_ALLOCATED_NS: Identify Namespace data structure for + * the specified allocated NSID + * @NVME_IDENTIFY_CNS_NS_CTRL_LIST: Controller List of controllers attached + * to the specified NSID + * @NVME_IDENTIFY_CNS_CTRL_LIST: Controller List of controllers that exist + * in the NVM subsystem + * @NVME_IDENTIFY_CNS_PRIMARY_CTRL_CAP: Primary Controller Capabilities data + * structure for the specified primary controller + * @NVME_IDENTIFY_CNS_SECONDARY_CTRL_LIST: Secondary Controller list of controllers + * associated with the primary controller + * processing the command + * @NVME_IDENTIFY_CNS_NS_GRANULARITY: A Namespace Granularity Lis + * @NVME_IDENTIFY_CNS_UUID_LIST: A UUID List + * @NVME_IDENTIFY_CNS_DOMAIN_LIST: Domain List + * @NVME_IDENTIFY_CNS_ENDURANCE_GROUP_ID: Endurance Group List + * @NVME_IDENTIFY_CNS_CSI_ALLOCATED_NS_LIST: I/O Command Set specific Allocated Namespace + * ID list + * @NVME_IDENTIFY_CNS_CSI_ID_NS_DATA_STRUCTURE: I/O Command Set specific ID Namespace + * Data Structure for Allocated Namespace ID + * @NVME_IDENTIFY_CNS_COMMAND_SET_STRUCTURE: Base Specification 2.0a section 5.17.2.21 + */ +enum nvme_identify_cns { + NVME_IDENTIFY_CNS_NS = 0x00, + NVME_IDENTIFY_CNS_CTRL = 0x01, + NVME_IDENTIFY_CNS_NS_ACTIVE_LIST = 0x02, + NVME_IDENTIFY_CNS_NS_DESC_LIST = 0x03, + NVME_IDENTIFY_CNS_NVMSET_LIST = 0x04, + NVME_IDENTIFY_CNS_CSI_NS = 0x05, + NVME_IDENTIFY_CNS_CSI_CTRL = 0x06, + NVME_IDENTIFY_CNS_CSI_NS_ACTIVE_LIST = 0x07, + NVME_IDENTIFY_CNS_CSI_INDEPENDENT_ID_NS = 0x08, + NVME_IDENTIFY_CNS_NS_USER_DATA_FORMAT = 0x09, + NVME_IDENTIFY_CNS_CSI_NS_USER_DATA_FORMAT = 0x0A, + NVME_IDENTIFY_CNS_ALLOCATED_NS_LIST = 0x10, + NVME_IDENTIFY_CNS_ALLOCATED_NS = 0x11, + NVME_IDENTIFY_CNS_NS_CTRL_LIST = 0x12, + NVME_IDENTIFY_CNS_CTRL_LIST = 0x13, + NVME_IDENTIFY_CNS_PRIMARY_CTRL_CAP = 0x14, + NVME_IDENTIFY_CNS_SECONDARY_CTRL_LIST = 0x15, + NVME_IDENTIFY_CNS_NS_GRANULARITY = 0x16, + NVME_IDENTIFY_CNS_UUID_LIST = 0x17, + NVME_IDENTIFY_CNS_DOMAIN_LIST = 0x18, + NVME_IDENTIFY_CNS_ENDURANCE_GROUP_ID = 0x19, + NVME_IDENTIFY_CNS_CSI_ALLOCATED_NS_LIST = 0x1A, + NVME_IDENTIFY_CNS_CSI_ID_NS_DATA_STRUCTURE = 0x1B, + NVME_IDENTIFY_CNS_COMMAND_SET_STRUCTURE = 0x1C, +}; + +/** + * enum nvme_cmd_get_log_lid - + * @NVME_LOG_LID_SUPPORTED_LOG_PAGES: Supported Log Pages + * @NVME_LOG_LID_ERROR: Error Information + * @NVME_LOG_LID_SMART: SMART / Health Information + * @NVME_LOG_LID_FW_SLOT: Firmware Slot Information + * @NVME_LOG_LID_CHANGED_NS: Changed Namespace List + * @NVME_LOG_LID_CMD_EFFECTS: Commands Supported and Effects + * @NVME_LOG_LID_DEVICE_SELF_TEST: Device Self-test + * @NVME_LOG_LID_TELEMETRY_HOST: Telemetry Host-Initiated + * @NVME_LOG_LID_TELEMETRY_CTRL: Telemetry Controller-Initiated + * @NVME_LOG_LID_ENDURANCE_GROUP: Endurance Group Information + * @NVME_LOG_LID_PREDICTABLE_LAT_NVMSET: Predictable Latency Per NVM Set + * @NVME_LOG_LID_PREDICTABLE_LAT_AGG: Predictable Latency Event Aggregate + * @NVME_LOG_LID_ANA: Asymmetric Namespace Access + * @NVME_LOG_LID_PERSISTENT_EVENT: Persistent Event Log + * @NVME_LOG_LID_LBA_STATUS: LBA Status Information + * @NVME_LOG_LID_ENDURANCE_GRP_EVT: Endurance Group Event Aggregate + * @NVME_LOG_LID_MEDIA_UNIT_STATUS: Media Unit Status + * @NVME_LOG_LID_SUPPORTED_CAP_CONFIG_LIST: Supported Capacity Configuration Lis + * @NVME_LOG_LID_FID_SUPPORTED_EFFECTS: Feature Identifiers Supported and Effects + * @NVME_LOG_LID_MI_CMD_SUPPORTED_EFFECTS: NVMe-MI Commands Supported and Effects + * @NVME_LOG_LID_BOOT_PARTITION: Boot Partition + * @NVME_LOG_LID_DISCOVER: Discovery + * @NVME_LOG_LID_RESERVATION: Reservation Notification + * @NVME_LOG_LID_SANITIZE: Sanitize Status + * @NVME_LOG_LID_ZNS_CHANGED_ZONES: Changed Zone List + */ +enum nvme_cmd_get_log_lid { + NVME_LOG_LID_SUPPORTED_LOG_PAGES = 0x00, + NVME_LOG_LID_ERROR = 0x01, + NVME_LOG_LID_SMART = 0x02, + NVME_LOG_LID_FW_SLOT = 0x03, + NVME_LOG_LID_CHANGED_NS = 0x04, + NVME_LOG_LID_CMD_EFFECTS = 0x05, + NVME_LOG_LID_DEVICE_SELF_TEST = 0x06, + NVME_LOG_LID_TELEMETRY_HOST = 0x07, + NVME_LOG_LID_TELEMETRY_CTRL = 0x08, + NVME_LOG_LID_ENDURANCE_GROUP = 0x09, + NVME_LOG_LID_PREDICTABLE_LAT_NVMSET = 0x0a, + NVME_LOG_LID_PREDICTABLE_LAT_AGG = 0x0b, + NVME_LOG_LID_ANA = 0x0c, + NVME_LOG_LID_PERSISTENT_EVENT = 0x0d, + NVME_LOG_LID_LBA_STATUS = 0x0e, + NVME_LOG_LID_ENDURANCE_GRP_EVT = 0x0f, + NVME_LOG_LID_MEDIA_UNIT_STATUS = 0x10, + NVME_LOG_LID_SUPPORTED_CAP_CONFIG_LIST = 0x11, + NVME_LOG_LID_FID_SUPPORTED_EFFECTS = 0x12, + NVME_LOG_LID_MI_CMD_SUPPORTED_EFFECTS = 0x13, + NVME_LOG_LID_BOOT_PARTITION = 0x15, + NVME_LOG_LID_DISCOVER = 0x70, + NVME_LOG_LID_RESERVATION = 0x80, + NVME_LOG_LID_SANITIZE = 0x81, + NVME_LOG_LID_ZNS_CHANGED_ZONES = 0xbf, +}; + +/** + * enum nvme_features_id - + * @NVME_FEAT_FID_ARBITRATION: Arbitration + * @NVME_FEAT_FID_POWER_MGMT: Power Management + * @NVME_FEAT_FID_LBA_RANGE: LBA Range Type + * @NVME_FEAT_FID_TEMP_THRESH: Temperature Threshold + * @NVME_FEAT_FID_ERR_RECOVERY: Error Recovery + * @NVME_FEAT_FID_VOLATILE_WC: Volatile Write Cache + * @NVME_FEAT_FID_NUM_QUEUES: Number of Queues + * @NVME_FEAT_FID_IRQ_COALESCE: Interrupt Coalescing + * @NVME_FEAT_FID_IRQ_CONFIG: Interrupt Vector Configuration + * @NVME_FEAT_FID_WRITE_ATOMIC: Write Atomicity Normal + * @NVME_FEAT_FID_ASYNC_EVENT: Asynchronous Event Configuration + * @NVME_FEAT_FID_AUTO_PST: Autonomous Power State Transition + * @NVME_FEAT_FID_HOST_MEM_BUF: Host Memory Buffer + * @NVME_FEAT_FID_TIMESTAMP: Timestamp + * @NVME_FEAT_FID_KATO: Keep Alive Timer + * @NVME_FEAT_FID_HCTM: Host Controlled Thermal Management + * @NVME_FEAT_FID_NOPSC: Non-Operational Power State Config + * @NVME_FEAT_FID_RRL: Read Recovery Level Config + * @NVME_FEAT_FID_PLM_CONFIG: Predictable Latency Mode Config + * @NVME_FEAT_FID_PLM_WINDOW: Predictable Latency Mode Window + * @NVME_FEAT_FID_LBA_STS_INTERVAL: LBA Status Information Report Interval + * @NVME_FEAT_FID_HOST_BEHAVIOR: Host Behavior Support + * @NVME_FEAT_FID_SANITIZE: Endurance Group Event Configuration + * @NVME_FEAT_FID_ENDURANCE_EVT_CFG: Endurance Group Event Configuration + * @NVME_FEAT_FID_IOCS_PROFILE: I/O Command Set Profile + * @NVME_FEAT_FID_SPINUP_CONTROL: Spinup Control + * @NVME_FEAT_FID_ENH_CTRL_METADATA: Enhanced Controller Metadata + * @NVME_FEAT_FID_CTRL_METADATA: Controller Metadata + * @NVME_FEAT_FID_NS_METADATA: Namespace Metadata + * @NVME_FEAT_FID_SW_PROGRESS: Software Progress Marker + * @NVME_FEAT_FID_HOST_ID: Host Identifier + * @NVME_FEAT_FID_RESV_MASK: Reservation Notification Mask + * @NVME_FEAT_FID_RESV_PERSIST: Reservation Persistence + * @NVME_FEAT_FID_WRITE_PROTECT: Namespace Write Protection Config + */ +enum nvme_features_id { + NVME_FEAT_FID_ARBITRATION = 0x01, + NVME_FEAT_FID_POWER_MGMT = 0x02, + NVME_FEAT_FID_LBA_RANGE = 0x03, + NVME_FEAT_FID_TEMP_THRESH = 0x04, + NVME_FEAT_FID_ERR_RECOVERY = 0x05, + NVME_FEAT_FID_VOLATILE_WC = 0x06, + NVME_FEAT_FID_NUM_QUEUES = 0x07, + NVME_FEAT_FID_IRQ_COALESCE = 0x08, + NVME_FEAT_FID_IRQ_CONFIG = 0x09, + NVME_FEAT_FID_WRITE_ATOMIC = 0x0a, + NVME_FEAT_FID_ASYNC_EVENT = 0x0b, + NVME_FEAT_FID_AUTO_PST = 0x0c, + NVME_FEAT_FID_HOST_MEM_BUF = 0x0d, + NVME_FEAT_FID_TIMESTAMP = 0x0e, + NVME_FEAT_FID_KATO = 0x0f, + NVME_FEAT_FID_HCTM = 0x10, + NVME_FEAT_FID_NOPSC = 0x11, + NVME_FEAT_FID_RRL = 0x12, + NVME_FEAT_FID_PLM_CONFIG = 0x13, + NVME_FEAT_FID_PLM_WINDOW = 0x14, + NVME_FEAT_FID_LBA_STS_INTERVAL = 0x15, + NVME_FEAT_FID_HOST_BEHAVIOR = 0x16, + NVME_FEAT_FID_SANITIZE = 0x17, + NVME_FEAT_FID_ENDURANCE_EVT_CFG = 0x18, + NVME_FEAT_FID_IOCS_PROFILE = 0x19, /* XXX: Placeholder until assigned */ + NVME_FEAT_FID_SPINUP_CONTROL = 0x1a, + NVME_FEAT_FID_ENH_CTRL_METADATA = 0x7d, + NVME_FEAT_FID_CTRL_METADATA = 0x7e, + NVME_FEAT_FID_NS_METADATA = 0x7f, + NVME_FEAT_FID_SW_PROGRESS = 0x80, + NVME_FEAT_FID_HOST_ID = 0x81, + NVME_FEAT_FID_RESV_MASK = 0x82, + NVME_FEAT_FID_RESV_PERSIST = 0x83, + NVME_FEAT_FID_WRITE_PROTECT = 0x84, +}; + +/** + * enum nvme_feat - + * @NVME_FEAT_ARBITRATION_BURST_SHIFT: + * @NVME_FEAT_ARBITRATION_BURST_MASK: + * @NVME_FEAT_ARBITRATION_LPW_SHIFT: + * @NVME_FEAT_ARBITRATION_LPW_MASK: + * @NVME_FEAT_ARBITRATION_MPW_SHIFT: + * @NVME_FEAT_ARBITRATION_MPW_MASK: + * @NVME_FEAT_ARBITRATION_HPW_SHIFT: + * @NVME_FEAT_ARBITRATION_HPW_MASK: + * @NVME_FEAT_PWRMGMT_PS_SHIFT: + * @NVME_FEAT_PWRMGMT_PS_MASK: + * @NVME_FEAT_PWRMGMT_WH_SHIFT: + * @NVME_FEAT_PWRMGMT_WH_MASK: + * @NVME_FEAT_LBAR_NR_SHIFT: + * @NVME_FEAT_LBAR_NR_MASK: + * @NVME_FEAT_TT_TMPTH_SHIFT: + * @NVME_FEAT_TT_TMPTH_MASK: + * @NVME_FEAT_TT_TMPSEL_SHIFT: + * @NVME_FEAT_TT_TMPSEL_MASK: + * @NVME_FEAT_TT_THSEL_SHIFT: + * @NVME_FEAT_TT_THSEL_MASK: + * @NVME_FEAT_ERROR_RECOVERY_TLER_SHIFT: + * @NVME_FEAT_ERROR_RECOVERY_TLER_MASK: + * @NVME_FEAT_ERROR_RECOVERY_DULBE_SHIFT: + * @NVME_FEAT_ERROR_RECOVERY_DULBE_MASK: + * @NVME_FEAT_VWC_WCE_SHIFT: + * @NVME_FEAT_VWC_WCE_MASK: + * @NVME_FEAT_NRQS_NSQR_SHIFT: + * @NVME_FEAT_NRQS_NSQR_MASK: + * @NVME_FEAT_NRQS_NCQR_SHIFT: + * @NVME_FEAT_NRQS_NCQR_MASK: + * @NVME_FEAT_IRQC_THR_SHIFT: + * @NVME_FEAT_IRQC_THR_MASK: + * @NVME_FEAT_IRQC_TIME_SHIFT: + * @NVME_FEAT_IRQC_TIME_MASK: + * @NVME_FEAT_ICFG_IV_SHIFT: + * @NVME_FEAT_ICFG_IV_MASK: + * @NVME_FEAT_ICFG_CD_SHIFT: + * @NVME_FEAT_ICFG_CD_MASK: + * @NVME_FEAT_WA_DN_SHIFT: + * @NVME_FEAT_WA_DN_MASK: + * @NVME_FEAT_AE_SMART_SHIFT: + * @NVME_FEAT_AE_SMART_MASK: + * @NVME_FEAT_AE_NAN_SHIFT: + * @NVME_FEAT_AE_NAN_MASK: + * @NVME_FEAT_AE_FW_SHIFT: + * @NVME_FEAT_AE_FW_MASK: + * @NVME_FEAT_AE_TELEM_SHIFT: + * @NVME_FEAT_AE_TELEM_MASK: + * @NVME_FEAT_AE_ANA_SHIFT: + * @NVME_FEAT_AE_ANA_MASK: + * @NVME_FEAT_AE_PLA_SHIFT: + * @NVME_FEAT_AE_PLA_MASK: + * @NVME_FEAT_AE_LBAS_SHIFT: + * @NVME_FEAT_AE_LBAS_MASK: + * @NVME_FEAT_AE_EGA_SHIFT: + * @NVME_FEAT_AE_EGA_MASK: + * @NVME_FEAT_APST_APSTE_SHIFT: + * @NVME_FEAT_APST_APSTE_MASK: + * @NVME_FEAT_HMEM_EHM_SHIFT: + * @NVME_FEAT_HMEM_EHM_MASK: + * @NVME_FEAT_HCTM_TMT2_SHIFT: + * @NVME_FEAT_HCTM_TMT2_MASK: + * @NVME_FEAT_HCTM_TMT1_SHIFT: + * @NVME_FEAT_HCTM_TMT1_MASK: + * @NVME_FEAT_NOPS_NOPPME_SHIFT: + * @NVME_FEAT_NOPS_NOPPME_MASK: + * @NVME_FEAT_RRL_RRL_SHIFT: + * @NVME_FEAT_RRL_RRL_MASK: + * @NVME_FEAT_PLM_PLME_SHIFT: + * @NVME_FEAT_PLM_PLME_MASK: + * @NVME_FEAT_PLMW_WS_SHIFT: + * @NVME_FEAT_PLMW_WS_MASK: + * @NVME_FEAT_LBAS_LSIRI_SHIFT: + * @NVME_FEAT_LBAS_LSIRI_MASK: + * @NVME_FEAT_LBAS_LSIPI_SHIFT: + * @NVME_FEAT_LBAS_LSIPI_MASK: + * @NVME_FEAT_SC_NODRM_SHIFT: + * @NVME_FEAT_SC_NODRM_MASK: + * @NVME_FEAT_EG_ENDGID_SHIFT: + * @NVME_FEAT_EG_ENDGID_MASK: + * @NVME_FEAT_EG_EGCW_SHIFT: + * @NVME_FEAT_EG_EGCW_MASK: + * @NVME_FEAT_SPM_PBSLC_SHIFT: + * @NVME_FEAT_SPM_PBSLC_MASK: + * @NVME_FEAT_HOSTID_EXHID_SHIFT: + * @NVME_FEAT_HOSTID_EXHID_MASK: + * @NVME_FEAT_RM_REGPRE_SHIFT: + * @NVME_FEAT_RM_REGPRE_MASK: + * @NVME_FEAT_RM_RESREL_SHIFT: + * @NVME_FEAT_RM_RESREL_MASK: + * @NVME_FEAT_RM_RESPRE_SHIFT: + * @NVME_FEAT_RM_RESPRE_MASK: + * @NVME_FEAT_RP_PTPL_SHIFT: + * @NVME_FEAT_RP_PTPL_MASK: + * @NVME_FEAT_WP_WPS_SHIFT: + * @NVME_FEAT_WP_WPS_MASK: + * @NVME_FEAT_IOCSP_IOCSCI_SHIFT: + * @NVME_FEAT_IOCSP_IOCSCI_MASK: + */ +enum nvme_feat { + NVME_FEAT_ARBITRATION_BURST_SHIFT = 0, + NVME_FEAT_ARBITRATION_BURST_MASK = 0x7, + NVME_FEAT_ARBITRATION_LPW_SHIFT = 8, + NVME_FEAT_ARBITRATION_LPW_MASK = 0xff, + NVME_FEAT_ARBITRATION_MPW_SHIFT = 16, + NVME_FEAT_ARBITRATION_MPW_MASK = 0xff, + NVME_FEAT_ARBITRATION_HPW_SHIFT = 24, + NVME_FEAT_ARBITRATION_HPW_MASK = 0xff, + NVME_FEAT_PWRMGMT_PS_SHIFT = 0, + NVME_FEAT_PWRMGMT_PS_MASK = 0x1f, + NVME_FEAT_PWRMGMT_WH_SHIFT = 5, + NVME_FEAT_PWRMGMT_WH_MASK = 0x7, + NVME_FEAT_LBAR_NR_SHIFT = 0, + NVME_FEAT_LBAR_NR_MASK = 0x3f, + NVME_FEAT_TT_TMPTH_SHIFT = 0, + NVME_FEAT_TT_TMPTH_MASK = 0xffff, + NVME_FEAT_TT_TMPSEL_SHIFT = 16, + NVME_FEAT_TT_TMPSEL_MASK = 0xf, + NVME_FEAT_TT_THSEL_SHIFT = 20, + NVME_FEAT_TT_THSEL_MASK = 0x3, + NVME_FEAT_ERROR_RECOVERY_TLER_SHIFT = 0, + NVME_FEAT_ERROR_RECOVERY_TLER_MASK = 0xffff, + NVME_FEAT_ERROR_RECOVERY_DULBE_SHIFT = 16, + NVME_FEAT_ERROR_RECOVERY_DULBE_MASK = 0x1, + NVME_FEAT_VWC_WCE_SHIFT = 0, + NVME_FEAT_VWC_WCE_MASK = 0x1, + NVME_FEAT_NRQS_NSQR_SHIFT = 0, + NVME_FEAT_NRQS_NSQR_MASK = 0xffff, + NVME_FEAT_NRQS_NCQR_SHIFT = 16, + NVME_FEAT_NRQS_NCQR_MASK = 0xffff, + NVME_FEAT_IRQC_THR_SHIFT = 0, + NVME_FEAT_IRQC_THR_MASK = 0xff, + NVME_FEAT_IRQC_TIME_SHIFT = 8, + NVME_FEAT_IRQC_TIME_MASK = 0xff, + NVME_FEAT_ICFG_IV_SHIFT = 0, + NVME_FEAT_ICFG_IV_MASK = 0xffff, + NVME_FEAT_ICFG_CD_SHIFT = 16, + NVME_FEAT_ICFG_CD_MASK = 0x1, + NVME_FEAT_WA_DN_SHIFT = 0, + NVME_FEAT_WA_DN_MASK = 0x1, + NVME_FEAT_AE_SMART_SHIFT = 0, + NVME_FEAT_AE_SMART_MASK = 0xff, + NVME_FEAT_AE_NAN_SHIFT = 8, + NVME_FEAT_AE_NAN_MASK = 0x1, + NVME_FEAT_AE_FW_SHIFT = 9, + NVME_FEAT_AE_FW_MASK = 0x1, + NVME_FEAT_AE_TELEM_SHIFT = 10, + NVME_FEAT_AE_TELEM_MASK = 0x1, + NVME_FEAT_AE_ANA_SHIFT = 11, + NVME_FEAT_AE_ANA_MASK = 0x1, + NVME_FEAT_AE_PLA_SHIFT = 12, + NVME_FEAT_AE_PLA_MASK = 0x1, + NVME_FEAT_AE_LBAS_SHIFT = 13, + NVME_FEAT_AE_LBAS_MASK = 0x1, + NVME_FEAT_AE_EGA_SHIFT = 14, + NVME_FEAT_AE_EGA_MASK = 0x1, + NVME_FEAT_APST_APSTE_SHIFT = 0, + NVME_FEAT_APST_APSTE_MASK = 0x1, + NVME_FEAT_HMEM_EHM_SHIFT = 0, + NVME_FEAT_HMEM_EHM_MASK = 0x1, + NVME_FEAT_HCTM_TMT2_SHIFT = 0, + NVME_FEAT_HCTM_TMT2_MASK = 0xffff, + NVME_FEAT_HCTM_TMT1_SHIFT = 16, + NVME_FEAT_HCTM_TMT1_MASK = 0xffff, + NVME_FEAT_NOPS_NOPPME_SHIFT = 0, + NVME_FEAT_NOPS_NOPPME_MASK = 0x1, + NVME_FEAT_RRL_RRL_SHIFT = 0, + NVME_FEAT_RRL_RRL_MASK = 0xff, + NVME_FEAT_PLM_PLME_SHIFT = 0, + NVME_FEAT_PLM_PLME_MASK = 0x1, + NVME_FEAT_PLMW_WS_SHIFT = 0, + NVME_FEAT_PLMW_WS_MASK = 0x7, + NVME_FEAT_LBAS_LSIRI_SHIFT = 0, + NVME_FEAT_LBAS_LSIRI_MASK = 0xffff, + NVME_FEAT_LBAS_LSIPI_SHIFT = 16, + NVME_FEAT_LBAS_LSIPI_MASK = 0xffff, + NVME_FEAT_SC_NODRM_SHIFT = 0, + NVME_FEAT_SC_NODRM_MASK = 0x1, + NVME_FEAT_EG_ENDGID_SHIFT = 0, + NVME_FEAT_EG_ENDGID_MASK = 0xffff, + NVME_FEAT_EG_EGCW_SHIFT = 16, + NVME_FEAT_EG_EGCW_MASK = 0xff, + NVME_FEAT_SPM_PBSLC_SHIFT = 0, + NVME_FEAT_SPM_PBSLC_MASK = 0xff, + NVME_FEAT_HOSTID_EXHID_SHIFT = 0, + NVME_FEAT_HOSTID_EXHID_MASK = 0x1, + NVME_FEAT_RM_REGPRE_SHIFT = 1, + NVME_FEAT_RM_REGPRE_MASK = 0x1, + NVME_FEAT_RM_RESREL_SHIFT = 2, + NVME_FEAT_RM_RESREL_MASK = 0x1, + NVME_FEAT_RM_RESPRE_SHIFT = 0x3, + NVME_FEAT_RM_RESPRE_MASK = 0x1, + NVME_FEAT_RP_PTPL_SHIFT = 0, + NVME_FEAT_RP_PTPL_MASK = 0x1, + NVME_FEAT_WP_WPS_SHIFT = 0, + NVME_FEAT_WP_WPS_MASK = 0x7, + NVME_FEAT_IOCSP_IOCSCI_SHIFT = 0, + NVME_FEAT_IOCSP_IOCSCI_MASK = 0xff, +}; + +/** + * enum nvme_get_features_sel - + * @NVME_GET_FEATURES_SEL_CURRENT: Current value + * @NVME_GET_FEATURES_SEL_DEFAULT: Default value + * @NVME_GET_FEATURES_SEL_SAVED: Saved value + * @NVME_GET_FEATURES_SEL_SUPPORTED: Supported capabilities + */ +enum nvme_get_features_sel { + NVME_GET_FEATURES_SEL_CURRENT = 0, + NVME_GET_FEATURES_SEL_DEFAULT = 1, + NVME_GET_FEATURES_SEL_SAVED = 2, + NVME_GET_FEATURES_SEL_SUPPORTED = 3, +}; + +/** + * enum nvme_cmd_format_mset - Format NVM - Metadata Settings + * @NVME_FORMAT_MSET_SEPARATE: indicates that the metadata is transferred + * as part of a separate buffer. + * @NVME_FORMAT_MSET_EXTENDED: indicates that the metadata is transferred + * as part of an extended data LBA. + */ +enum nvme_cmd_format_mset { + NVME_FORMAT_MSET_SEPARATE = 0, + NVME_FORMAT_MSET_EXTENDED = 1, +}; + +/** + * enum nvme_cmd_format_pi - Format NVM - Protection Information + * @NVME_FORMAT_PI_DISABLE: Protection information is not enabled. + * @NVME_FORMAT_PI_TYPE1: Protection information is enabled, Type 1. + * @NVME_FORMAT_PI_TYPE2: Protection information is enabled, Type 2. + * @NVME_FORMAT_PI_TYPE3: Protection information is enabled, Type 3. + */ +enum nvme_cmd_format_pi { + NVME_FORMAT_PI_DISABLE = 0, + NVME_FORMAT_PI_TYPE1 = 1, + NVME_FORMAT_PI_TYPE2 = 2, + NVME_FORMAT_PI_TYPE3 = 3, +}; + +/** + * enum nvme_cmd_format_pil - Format NVM - Protection Information Location + * @NVME_FORMAT_PIL_LAST: Protection information is transferred as the last + * bytes of metadata. + * @NVME_FORMAT_PIL_FIRST: Protection information is transferred as the first + * bytes of metadata. + */ +enum nvme_cmd_format_pil { + NVME_FORMAT_PIL_LAST = 0, + NVME_FORMAT_PIL_FIRST = 1, +}; + +/** + * enum nvme_cmd_format_ses - Format NVM - Secure Erase Settings + * @NVME_FORMAT_SES_NONE: No secure erase operation requested. + * @NVME_FORMAT_SES_USER_DATA_ERASE: User Data Erase: All user data shall be erased, + * contents of the user data after the erase is + * indeterminate (e.g. the user data may be zero + * filled, one filled, etc.). If a User Data Erase + * is requested and all affected user data is + * encrypted, then the controller is allowed + * to use a cryptographic erase to perform + * the requested User Data Erase. + * @NVME_FORMAT_SES_CRYPTO_ERASE: Cryptographic Erase: All user data shall + * be erased cryptographically. This is + * accomplished by deleting the encryption key. + */ +enum nvme_cmd_format_ses { + NVME_FORMAT_SES_NONE = 0, + NVME_FORMAT_SES_USER_DATA_ERASE = 1, + NVME_FORMAT_SES_CRYPTO_ERASE = 2, +}; + +/** + * enum nvme_ns_mgmt_sel - + * @NVME_NS_MGMT_SEL_CREATE: Namespace Create selection + * @NVME_NS_MGMT_SEL_DELETE: Namespace Delete selection + */ +enum nvme_ns_mgmt_sel { + NVME_NS_MGMT_SEL_CREATE = 0, + NVME_NS_MGMT_SEL_DELETE = 1, +}; + +/** + * enum nvme_ns_attach_sel - + * @NVME_NS_ATTACH_SEL_CTRL_ATTACH: Namespace attach selection + * @NVME_NS_ATTACH_SEL_CTRL_DEATTACH: Namespace detach selection + */ +enum nvme_ns_attach_sel { + NVME_NS_ATTACH_SEL_CTRL_ATTACH = 0, + NVME_NS_ATTACH_SEL_CTRL_DEATTACH = 1, +}; + +/** + * enum nvme_fw_commit_ca - + * @NVME_FW_COMMIT_CA_REPLACE: Downloaded image replaces the existing + * image, if any, in the specified Firmware + * Slot. The newly placed image is not + * activated. + * @NVME_FW_COMMIT_CA_REPLACE_AND_ACTIVATE: Downloaded image replaces the existing + * image, if any, in the specified Firmware + * Slot. The newly placed image is activated + * at the next Controller Level Reset. + * @NVME_FW_COMMIT_CA_SET_ACTIVE: The existing image in the specified + * Firmware Slot is activated at the + * next Controller Level Reset. + * @NVME_FW_COMMIT_CA_REPLACE_AND_ACTIVATE_IMMEDIATE: Downloaded image replaces the existing + * image, if any, in the specified Firmware + * Slot and is then activated immediately. + * If there is not a newly downloaded image, + * then the existing image in the specified + * firmware slot is activated immediately. + * @NVME_FW_COMMIT_CA_REPLACE_BOOT_PARTITION: Downloaded image replaces the Boot + * Partition specified by the Boot + * Partition ID field. + * @NVME_FW_COMMIT_CA_ACTIVATE_BOOT_PARTITION: Mark the Boot Partition specified in + * the BPID field as active and update + * BPINFO.ABPID. + */ +enum nvme_fw_commit_ca { + NVME_FW_COMMIT_CA_REPLACE = 0, + NVME_FW_COMMIT_CA_REPLACE_AND_ACTIVATE = 1, + NVME_FW_COMMIT_CA_SET_ACTIVE = 2, + NVME_FW_COMMIT_CA_REPLACE_AND_ACTIVATE_IMMEDIATE = 3, + NVME_FW_COMMIT_CA_REPLACE_BOOT_PARTITION = 6, + NVME_FW_COMMIT_CA_ACTIVATE_BOOT_PARTITION = 7, +}; + +/** + * enum nvme_directive_dtype - + * @NVME_DIRECTIVE_DTYPE_IDENTIFY: Identify directive type + * @NVME_DIRECTIVE_DTYPE_STREAMS: Streams directive type + */ +enum nvme_directive_dtype { + NVME_DIRECTIVE_DTYPE_IDENTIFY = 0, + NVME_DIRECTIVE_DTYPE_STREAMS = 1, +}; + +/** + * enum nvme_directive_receive_doper - + * @NVME_DIRECTIVE_RECEIVE_IDENTIFY_DOPER_PARAM: + * @NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_PARAM: + * @NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_STATUS: + * @NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_RESOURCE: + */ +enum nvme_directive_receive_doper { + NVME_DIRECTIVE_RECEIVE_IDENTIFY_DOPER_PARAM = 0x01, + NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_PARAM = 0x01, + NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_STATUS = 0x02, + NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_RESOURCE = 0x03, +}; + +/** + * enum nvme_directive_send_doper - + * @NVME_DIRECTIVE_SEND_IDENTIFY_DOPER_ENDIR: + * @NVME_DIRECTIVE_SEND_STREAMS_DOPER_RELEASE_IDENTIFIER: + * @NVME_DIRECTIVE_SEND_STREAMS_DOPER_RELEASE_RESOURCE: + */ +enum nvme_directive_send_doper { + NVME_DIRECTIVE_SEND_IDENTIFY_DOPER_ENDIR = 0x01, + NVME_DIRECTIVE_SEND_STREAMS_DOPER_RELEASE_IDENTIFIER = 0x01, + NVME_DIRECTIVE_SEND_STREAMS_DOPER_RELEASE_RESOURCE = 0x02, +}; + +/** + * enum nvme_directive_send_identify_endir - + * @NVME_DIRECTIVE_SEND_IDENTIFY_ENDIR_DISABLE: + * @NVME_DIRECTIVE_SEND_IDENTIFY_ENDIR_ENABLE: + */ +enum nvme_directive_send_identify_endir { + NVME_DIRECTIVE_SEND_IDENTIFY_ENDIR_DISABLE = 0, + NVME_DIRECTIVE_SEND_IDENTIFY_ENDIR_ENABLE = 1, +}; + +/** + * enum nvme_sanitize_sanact - Sanitize Action + * @NVME_SANITIZE_SANACT_EXIT_FAILURE: Exit Failure Mode. + * @NVME_SANITIZE_SANACT_START_BLOCK_ERASE: Start a Block Erase sanitize operation. + * @NVME_SANITIZE_SANACT_START_OVERWRITE: Start an Overwrite sanitize operation. + * @NVME_SANITIZE_SANACT_START_CRYPTO_ERASE: Start a Crypto Erase sanitize operation. + */ +enum nvme_sanitize_sanact { + NVME_SANITIZE_SANACT_EXIT_FAILURE = 1, + NVME_SANITIZE_SANACT_START_BLOCK_ERASE = 2, + NVME_SANITIZE_SANACT_START_OVERWRITE = 3, + NVME_SANITIZE_SANACT_START_CRYPTO_ERASE = 4, +}; + +/** + * enum nvme_dst_stc - Action taken by the Device Self-test command + * @NVME_DST_STC_SHORT: Start a short device self-test operation + * @NVME_DST_STC_LONG: Start an extended device self-test operation + * @NVME_DST_STC_VS: Start a vendor specific device self-test operation + * @NVME_DST_STC_ABORT: Abort device self-test operation + */ +enum nvme_dst_stc { + NVME_DST_STC_SHORT = 0x1, + NVME_DST_STC_LONG = 0x2, + NVME_DST_STC_VS = 0xe, + NVME_DST_STC_ABORT = 0xf, +}; + +/** + * enum nvme_virt_mgmt_act - + * @NVME_VIRT_MGMT_ACT_PRIM_CTRL_FLEX_ALLOC: Primary Controller Flexible + * Allocation + * @NVME_VIRT_MGMT_ACT_OFFLINE_SEC_CTRL: Secondary Controller Offline + * @NVME_VIRT_MGMT_ACT_ASSIGN_SEC_CTRL: Secondary Controller Assign + * @NVME_VIRT_MGMT_ACT_ONLINE_SEC_CTRL: Secondary Controller Online + */ +enum nvme_virt_mgmt_act { + NVME_VIRT_MGMT_ACT_PRIM_CTRL_FLEX_ALLOC = 1, + NVME_VIRT_MGMT_ACT_OFFLINE_SEC_CTRL = 7, + NVME_VIRT_MGMT_ACT_ASSIGN_SEC_CTRL = 8, + NVME_VIRT_MGMT_ACT_ONLINE_SEC_CTRL = 9, +}; + +/** + * enum nvme_virt_mgmt_rt - + * @NVME_VIRT_MGMT_RT_VQ_RESOURCE: VQ Resources + * @NVME_VIRT_MGMT_RT_VI_RESOURCE: VI Resources + */ +enum nvme_virt_mgmt_rt { + NVME_VIRT_MGMT_RT_VQ_RESOURCE = 0, + NVME_VIRT_MGMT_RT_VI_RESOURCE = 1, +}; + +/** + * enum nvme_ns_write_protect_cfg - + * @NVME_NS_WP_CFG_NONE: No Write Protect + * @NVME_NS_WP_CFG_PROTECT: Write Protect + * @NVME_NS_WP_CFG_PROTECT_POWER_CYCLE: Write Protect Until Power Cycle + * @NVME_NS_WP_CFG_PROTECT_PERMANENT: Permanent Write Protect + */ +enum nvme_ns_write_protect_cfg { + NVME_NS_WP_CFG_NONE = 0, + NVME_NS_WP_CFG_PROTECT = 1, + NVME_NS_WP_CFG_PROTECT_POWER_CYCLE = 2, + NVME_NS_WP_CFG_PROTECT_PERMANENT = 3, +}; + +/** + * enum nvme_log_ana_lsp - + * @NVME_LOG_ANA_LSP_RGO_NAMESPACES: + * @NVME_LOG_ANA_LSP_RGO_GROUPS_ONLY: + */ +enum nvme_log_ana_lsp { + NVME_LOG_ANA_LSP_RGO_NAMESPACES = 0, + NVME_LOG_ANA_LSP_RGO_GROUPS_ONLY = 1, +}; + +/** + * enum nvme_pevent_log_action - + * @NVME_PEVENT_LOG_READ: Read Log Data + * @NVME_PEVENT_LOG_EST_CTX_AND_READ: Establish Context and Read Log Data + * @NVME_PEVENT_LOG_RELEASE_CTX: Release Context + */ +enum nvme_pevent_log_action { + NVME_PEVENT_LOG_READ = 0x0, + NVME_PEVENT_LOG_EST_CTX_AND_READ = 0x1, + NVME_PEVENT_LOG_RELEASE_CTX = 0x2, +}; + +/** + * enum nvme_feat_tmpthresh_thsel - + * @NVME_FEATURE_TEMPTHRESH_THSEL_OVER: Over temperature threshold select + * @NVME_FEATURE_TEMPTHRESH_THSEL_UNDER: Under temperature threshold select + */ +enum nvme_feat_tmpthresh_thsel { + NVME_FEATURE_TEMPTHRESH_THSEL_OVER = 0, + NVME_FEATURE_TEMPTHRESH_THSEL_UNDER = 1, +}; + +/** + * enum nvme_features_async_event_config_flags - + * @NVME_FEATURE_AENCFG_SMART_CRIT_SPARE: + * @NVME_FEATURE_AENCFG_SMART_CRIT_TEMPERATURE: + * @NVME_FEATURE_AENCFG_SMART_CRIT_DEGRADED: + * @NVME_FEATURE_AENCFG_SMART_CRIT_READ_ONLY: + * @NVME_FEATURE_AENCFG_SMART_CRIT_VOLATILE_BACKUP: + * @NVME_FEATURE_AENCFG_SMART_CRIT_READ_ONLY_PMR: + * @NVME_FEATURE_AENCFG_NOTICE_NAMESPACE_ATTRIBUTES: + * @NVME_FEATURE_AENCFG_NOTICE_FIRMWARE_ACTIVATION: + * @NVME_FEATURE_AENCFG_NOTICE_TELEMETRY_LOG: + * @NVME_FEATURE_AENCFG_NOTICE_ANA_CHANGE: + * @NVME_FEATURE_AENCFG_NOTICE_PL_EVENT: + * @NVME_FEATURE_AENCFG_NOTICE_LBA_STATUS: + * @NVME_FEATURE_AENCFG_NOTICE_EG_EVENT: + * @NVME_FEATURE_AENCFG_NOTICE_DISCOVERY_CHANGE: + */ +enum nvme_features_async_event_config_flags { + NVME_FEATURE_AENCFG_SMART_CRIT_SPARE = 1 << 0, + NVME_FEATURE_AENCFG_SMART_CRIT_TEMPERATURE = 1 << 1, + NVME_FEATURE_AENCFG_SMART_CRIT_DEGRADED = 1 << 2, + NVME_FEATURE_AENCFG_SMART_CRIT_READ_ONLY = 1 << 3, + NVME_FEATURE_AENCFG_SMART_CRIT_VOLATILE_BACKUP = 1 << 4, + NVME_FEATURE_AENCFG_SMART_CRIT_READ_ONLY_PMR = 1 << 5, + NVME_FEATURE_AENCFG_NOTICE_NAMESPACE_ATTRIBUTES = 1 << 8, + NVME_FEATURE_AENCFG_NOTICE_FIRMWARE_ACTIVATION = 1 << 9, + NVME_FEATURE_AENCFG_NOTICE_TELEMETRY_LOG = 1 << 10, + NVME_FEATURE_AENCFG_NOTICE_ANA_CHANGE = 1 << 11, + NVME_FEATURE_AENCFG_NOTICE_PL_EVENT = 1 << 12, + NVME_FEATURE_AENCFG_NOTICE_LBA_STATUS = 1 << 13, + NVME_FEATURE_AENCFG_NOTICE_EG_EVENT = 1 << 14, + NVME_FEATURE_AENCFG_NOTICE_DISCOVERY_CHANGE = 1 << 31, +}; + +/** + * enum nvme_feat_plm_window_select - + * @NVME_FEATURE_PLM_DTWIN: Deterministic Window select + * @NVME_FEATURE_PLM_NDWIN: Non-Deterministic Window select + */ +enum nvme_feat_plm_window_select { + NVME_FEATURE_PLM_DTWIN = 1, + NVME_FEATURE_PLM_NDWIN = 2, +}; + +/** + * enum nvme_feat_resv_notify_flags - + * @NVME_FEAT_RESV_NOTIFY_REGPRE: Mask Registration Preempted Notification + * @NVME_FEAT_RESV_NOTIFY_RESREL: Mask Reservation Released Notification + * @NVME_FEAT_RESV_NOTIFY_RESPRE: Mask Reservation Preempted Notification + */ +enum nvme_feat_resv_notify_flags { + NVME_FEAT_RESV_NOTIFY_REGPRE = 1 << 1, + NVME_FEAT_RESV_NOTIFY_RESREL = 1 << 2, + NVME_FEAT_RESV_NOTIFY_RESPRE = 1 << 3, +}; + +/** + * enum nvme_feat_nswpcfg_state - + * @NVME_FEAT_NS_NO_WRITE_PROTECT: No Write Protect + * @NVME_FEAT_NS_WRITE_PROTECT: Write Protect + * @NVME_FEAT_NS_WRITE_PROTECT_PWR_CYCLE: Write Protect Until Power Cycle + * @NVME_FEAT_NS_WRITE_PROTECT_PERMANENT: Permanent Write Protect + */ +enum nvme_feat_nswpcfg_state { + NVME_FEAT_NS_NO_WRITE_PROTECT = 0, + NVME_FEAT_NS_WRITE_PROTECT = 1, + NVME_FEAT_NS_WRITE_PROTECT_PWR_CYCLE = 2, + NVME_FEAT_NS_WRITE_PROTECT_PERMANENT = 3, +}; + +/** + * enum nvme_fctype - + * @nvme_fabrics_type_property_set: Property set + * @nvme_fabrics_type_connect: Connect + * @nvme_fabrics_type_property_get: Property Get + * @nvme_fabrics_type_auth_send: Authentication Send + * @nvme_fabrics_type_auth_receive: Authentication Receive + * @nvme_fabrics_type_disconnect: Disconnect + */ +enum nvme_fctype { + nvme_fabrics_type_property_set = 0x00, + nvme_fabrics_type_connect = 0x01, + nvme_fabrics_type_property_get = 0x04, + nvme_fabrics_type_auth_send = 0x05, + nvme_fabrics_type_auth_receive = 0x06, + nvme_fabrics_type_disconnect = 0x08, +}; + +/** + * enum nvme_io_opcode - + * @nvme_cmd_flush: Flush + * @nvme_cmd_write: Write + * @nvme_cmd_read: Read + * @nvme_cmd_write_uncor: Write Uncorrectable + * @nvme_cmd_compare: Compare + * @nvme_cmd_write_zeroes: write Zeros + * @nvme_cmd_dsm: Dataset Management + * @nvme_cmd_verify: Verify + * @nvme_cmd_resv_register: Reservation Register + * @nvme_cmd_resv_report: Reservation Report + * @nvme_cmd_resv_acquire: Reservation Acquire + * @nvme_cmd_resv_release: Reservation Release + * @nvme_cmd_copy: Copy + * @nvme_zns_cmd_mgmt_send: Zone Management Send + * @nvme_zns_cmd_mgmt_recv: Zone Management Receive + * @nvme_zns_cmd_append: Zone Append + */ +enum nvme_io_opcode { + nvme_cmd_flush = 0x00, + nvme_cmd_write = 0x01, + nvme_cmd_read = 0x02, + nvme_cmd_write_uncor = 0x04, + nvme_cmd_compare = 0x05, + nvme_cmd_write_zeroes = 0x08, + nvme_cmd_dsm = 0x09, + nvme_cmd_verify = 0x0c, + nvme_cmd_resv_register = 0x0d, + nvme_cmd_resv_report = 0x0e, + nvme_cmd_resv_acquire = 0x11, + nvme_cmd_resv_release = 0x15, + nvme_cmd_copy = 0x19, + nvme_zns_cmd_mgmt_send = 0x79, + nvme_zns_cmd_mgmt_recv = 0x7a, + nvme_zns_cmd_append = 0x7d, +}; + +/** + * enum nvme_io_control_flags - + * @NVME_IO_DTYPE_STREAMS: Directive Type Streams + * @NVME_IO_DEAC: Deallocate + * @NVME_IO_ZNS_APPEND_PIREMAP: Protection Information Remap + * @NVME_IO_PRINFO_PRCHK_REF: Protection Information Check Reference Tag + * @NVME_IO_PRINFO_PRCHK_APP: Protection Information Check Application Tag + * @NVME_IO_PRINFO_PRCHK_GUARD: Protection Information Check Guard field + * @NVME_IO_PRINFO_PRACT: Protection Information Action + * @NVME_IO_FUA: Force Unit Access + * @NVME_IO_LR: Limited Retry + */ +enum nvme_io_control_flags { + NVME_IO_DTYPE_STREAMS = 1 << 4, + NVME_IO_DEAC = 1 << 9, + NVME_IO_ZNS_APPEND_PIREMAP = 1 << 9, + NVME_IO_PRINFO_PRCHK_REF = 1 << 10, + NVME_IO_PRINFO_PRCHK_APP = 1 << 11, + NVME_IO_PRINFO_PRCHK_GUARD = 1 << 12, + NVME_IO_PRINFO_PRACT = 1 << 13, + NVME_IO_FUA = 1 << 14, + NVME_IO_LR = 1 << 15, +}; + +/** + * enum nvme_io_dsm_flags - + * @NVME_IO_DSM_FREQ_UNSPEC: No frequency information provided + * @NVME_IO_DSM_FREQ_TYPICAL: Typical number of reads and writes + * expected for this LBA range + * @NVME_IO_DSM_FREQ_RARE: Infrequent writes and infrequent + * reads to the LBA range indicated + * @NVME_IO_DSM_FREQ_READS: Infrequent writes and frequent + * reads to the LBA range indicated + * @NVME_IO_DSM_FREQ_WRITES: Frequent writes and infrequent + * reads to the LBA range indicated + * @NVME_IO_DSM_FREQ_RW: Frequent writes and frequent reads + * to the LBA range indicated + * @NVME_IO_DSM_FREQ_ONCE: + * @NVME_IO_DSM_FREQ_PREFETCH: + * @NVME_IO_DSM_FREQ_TEMP: + * @NVME_IO_DSM_LATENCY_NONE: No latency information provided + * @NVME_IO_DSM_LATENCY_IDLE: Longer latency acceptable + * @NVME_IO_DSM_LATENCY_NORM: Typical latency + * @NVME_IO_DSM_LATENCY_LOW: Smallest possible latency + * @NVME_IO_DSM_SEQ_REQ: + * @NVME_IO_DSM_COMPRESSED: + */ +enum nvme_io_dsm_flags { + NVME_IO_DSM_FREQ_UNSPEC = 0, + NVME_IO_DSM_FREQ_TYPICAL = 1, + NVME_IO_DSM_FREQ_RARE = 2, + NVME_IO_DSM_FREQ_READS = 3, + NVME_IO_DSM_FREQ_WRITES = 4, + NVME_IO_DSM_FREQ_RW = 5, + NVME_IO_DSM_FREQ_ONCE = 6, + NVME_IO_DSM_FREQ_PREFETCH = 7, + NVME_IO_DSM_FREQ_TEMP = 8, + NVME_IO_DSM_LATENCY_NONE = 0 << 4, + NVME_IO_DSM_LATENCY_IDLE = 1 << 4, + NVME_IO_DSM_LATENCY_NORM = 2 << 4, + NVME_IO_DSM_LATENCY_LOW = 3 << 4, + NVME_IO_DSM_SEQ_REQ = 1 << 6, + NVME_IO_DSM_COMPRESSED = 1 << 7, +}; + +/** + * enum nvme_dsm_attributes - + * @NVME_DSMGMT_IDR: Attribute – Integral Dataset for Read + * @NVME_DSMGMT_IDW: Attribute – Integral Dataset for Write + * @NVME_DSMGMT_AD: Attribute – Deallocate + */ +enum nvme_dsm_attributes { + NVME_DSMGMT_IDR = 1 << 0, + NVME_DSMGMT_IDW = 1 << 1, + NVME_DSMGMT_AD = 1 << 2, +}; + +/** + * enum nvme_resv_rtype - + * @NVME_RESERVATION_RTYPE_WE: Write Exclusive Reservation + * @NVME_RESERVATION_RTYPE_EA: Exclusive Access Reservation + * @NVME_RESERVATION_RTYPE_WERO: Write Exclusive - Registrants Only Reservation + * @NVME_RESERVATION_RTYPE_EARO: Exclusive Access - Registrants Only Reservation + * @NVME_RESERVATION_RTYPE_WEAR: Write Exclusive - All Registrants Reservation + * @NVME_RESERVATION_RTYPE_EAAR: Exclusive Access - All Registrants Reservation + */ +enum nvme_resv_rtype { + NVME_RESERVATION_RTYPE_WE = 1, + NVME_RESERVATION_RTYPE_EA = 2, + NVME_RESERVATION_RTYPE_WERO = 3, + NVME_RESERVATION_RTYPE_EARO = 4, + NVME_RESERVATION_RTYPE_WEAR = 5, + NVME_RESERVATION_RTYPE_EAAR = 6, +}; + +/** + * enum nvme_resv_racqa - + * @NVME_RESERVATION_RACQA_ACQUIRE: Acquire + * @NVME_RESERVATION_RACQA_PREEMPT: Preempt + * @NVME_RESERVATION_RACQA_PREEMPT_AND_ABORT: Preempt and Abort + */ +enum nvme_resv_racqa { + NVME_RESERVATION_RACQA_ACQUIRE = 0, + NVME_RESERVATION_RACQA_PREEMPT = 1, + NVME_RESERVATION_RACQA_PREEMPT_AND_ABORT = 2, +}; + +/** + * enum nvme_resv_rrega - + * @NVME_RESERVATION_RREGA_REGISTER_KEY: Register Reservation Key + * @NVME_RESERVATION_RREGA_UNREGISTER_KEY: Unregister Reservation Key + * @NVME_RESERVATION_RREGA_REPLACE_KEY: Replace Reservation Key + */ +enum nvme_resv_rrega { + NVME_RESERVATION_RREGA_REGISTER_KEY = 0, + NVME_RESERVATION_RREGA_UNREGISTER_KEY = 1, + NVME_RESERVATION_RREGA_REPLACE_KEY = 2, +}; + +/** + * enum nvme_resv_cptpl - + * @NVME_RESERVATION_CPTPL_NO_CHANGE: No change to PTPL state + * @NVME_RESERVATION_CPTPL_CLEAR: Reservations are released and + * registrants are cleared on a power on + * @NVME_RESERVATION_CPTPL_PERSIST: Reservations and registrants persist + * across a power loss + */ +enum nvme_resv_cptpl { + NVME_RESERVATION_CPTPL_NO_CHANGE = 0, + NVME_RESERVATION_CPTPL_CLEAR = 2, + NVME_RESERVATION_CPTPL_PERSIST = 3, +}; + +/** + * enum nvme_resv_rrela - + * @NVME_RESERVATION_RRELA_RELEASE: Release + * @NVME_RESERVATION_RRELA_CLEAR: Clear + */ +enum nvme_resv_rrela { + NVME_RESERVATION_RRELA_RELEASE = 0, + NVME_RESERVATION_RRELA_CLEAR = 1 +}; + +/** + * enum nvme_zns_send_action - + * @NVME_ZNS_ZSA_CLOSE: Close Zone + * @NVME_ZNS_ZSA_FINISH: Finish Zone + * @NVME_ZNS_ZSA_OPEN: Open Zone + * @NVME_ZNS_ZSA_RESET: Reset Zone + * @NVME_ZNS_ZSA_OFFLINE: Offline Zone + * @NVME_ZNS_ZSA_SET_DESC_EXT: Set Zone Descriptor Extension + * @NVME_ZNS_ZSA_ZRWA_FLUSH: Flush + */ +enum nvme_zns_send_action { + NVME_ZNS_ZSA_CLOSE = 0x1, + NVME_ZNS_ZSA_FINISH = 0x2, + NVME_ZNS_ZSA_OPEN = 0x3, + NVME_ZNS_ZSA_RESET = 0x4, + NVME_ZNS_ZSA_OFFLINE = 0x5, + NVME_ZNS_ZSA_SET_DESC_EXT = 0x10, + NVME_ZNS_ZSA_ZRWA_FLUSH = 0x11, +}; + +/** + * enum nvme_zns_recv_action - + * @NVME_ZNS_ZRA_REPORT_ZONES: Report Zones + * @NVME_ZNS_ZRA_EXTENDED_REPORT_ZONES: Extended Report Zones + */ +enum nvme_zns_recv_action { + NVME_ZNS_ZRA_REPORT_ZONES = 0x0, + NVME_ZNS_ZRA_EXTENDED_REPORT_ZONES = 0x1, +}; + +/** + * enum nvme_zns_report_options - + * @NVME_ZNS_ZRAS_REPORT_ALL: List all zones + * @NVME_ZNS_ZRAS_REPORT_EMPTY: List the zones in the ZSE:Empty state + * @NVME_ZNS_ZRAS_REPORT_IMPL_OPENED: List the zones in the ZSIO:Implicitly Opened state + * @NVME_ZNS_ZRAS_REPORT_EXPL_OPENED: List the zones in the ZSEO:Explicitly Opened state + * @NVME_ZNS_ZRAS_REPORT_CLOSED: List the zones in the ZSC:Closed state + * @NVME_ZNS_ZRAS_REPORT_FULL: List the zones in the ZSF:Full state + * @NVME_ZNS_ZRAS_REPORT_READ_ONLY: List the zones in the ZSRO:Read Only state + * @NVME_ZNS_ZRAS_REPORT_OFFLINE: List the zones in the ZSO:Offline state + */ +enum nvme_zns_report_options { + NVME_ZNS_ZRAS_REPORT_ALL = 0x0, + NVME_ZNS_ZRAS_REPORT_EMPTY = 0x1, + NVME_ZNS_ZRAS_REPORT_IMPL_OPENED = 0x2, + NVME_ZNS_ZRAS_REPORT_EXPL_OPENED = 0x3, + NVME_ZNS_ZRAS_REPORT_CLOSED = 0x4, + NVME_ZNS_ZRAS_REPORT_FULL = 0x5, + NVME_ZNS_ZRAS_REPORT_READ_ONLY = 0x6, + NVME_ZNS_ZRAS_REPORT_OFFLINE = 0x7, +}; + +#endif /* _LIBNVME_TYPES_H */ diff --git a/src/nvme/util.c b/src/nvme/util.c new file mode 100644 index 0000000..799c0cf --- /dev/null +++ b/src/nvme/util.c @@ -0,0 +1,777 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/* + * This file is part of libnvme. + * Copyright (c) 2020 Western Digital Corporation or its affiliates. + * + * Authors: Keith Busch <keith.busch@wdc.com> + * Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com> + */ + +#include <stdio.h> +#include <string.h> +#include <errno.h> + +#include <sys/param.h> +#include <sys/types.h> +#include <arpa/inet.h> +#include <netdb.h> +#include <unistd.h> + +#include <ccan/endian/endian.h> + +#include "private.h" +#include "util.h" +#include "log.h" + +static inline __u8 nvme_generic_status_to_errno(__u16 status) +{ + switch (status) { + case NVME_SC_INVALID_OPCODE: + case NVME_SC_INVALID_FIELD: + case NVME_SC_INVALID_NS: + case NVME_SC_SGL_INVALID_LAST: + case NVME_SC_SGL_INVALID_COUNT: + case NVME_SC_SGL_INVALID_DATA: + case NVME_SC_SGL_INVALID_METADATA: + case NVME_SC_SGL_INVALID_TYPE: + case NVME_SC_SGL_INVALID_OFFSET: + case NVME_SC_PRP_INVALID_OFFSET: + case NVME_SC_CMB_INVALID_USE: + case NVME_SC_KAT_INVALID: + return EINVAL; + case NVME_SC_CMDID_CONFLICT: + return EADDRINUSE; + case NVME_SC_DATA_XFER_ERROR: + case NVME_SC_INTERNAL: + case NVME_SC_SANITIZE_FAILED: + return EIO; + case NVME_SC_POWER_LOSS: + case NVME_SC_ABORT_REQ: + case NVME_SC_ABORT_QUEUE: + case NVME_SC_FUSED_FAIL: + case NVME_SC_FUSED_MISSING: + return EWOULDBLOCK; + case NVME_SC_CMD_SEQ_ERROR: + return EILSEQ; + case NVME_SC_SANITIZE_IN_PROGRESS: + case NVME_SC_FORMAT_IN_PROGRESS: + return EINPROGRESS; + case NVME_SC_NS_WRITE_PROTECTED: + case NVME_SC_NS_NOT_READY: + case NVME_SC_RESERVATION_CONFLICT: + case NVME_SC_OP_DENIED: + case NVME_SC_ADMIN_CMD_MEDIA_NOT_READY: + return EACCES; + case NVME_SC_LBA_RANGE: + return EREMOTEIO; + case NVME_SC_CAP_EXCEEDED: + case NVME_SC_AWU_EXCEEDED: + return ENOSPC; + } + return EIO; +} + +static inline __u8 nvme_cmd_specific_status_to_errno(__u16 status) +{ + switch (status) { + case NVME_SC_CQ_INVALID: + case NVME_SC_QID_INVALID: + case NVME_SC_QUEUE_SIZE: + case NVME_SC_FIRMWARE_SLOT: + case NVME_SC_FIRMWARE_IMAGE: + case NVME_SC_INVALID_VECTOR: + case NVME_SC_INVALID_LOG_PAGE: + case NVME_SC_INVALID_FORMAT: + case NVME_SC_INVALID_QUEUE: + case NVME_SC_NS_INSUFFICIENT_CAP: + case NVME_SC_NS_ID_UNAVAILABLE: + case NVME_SC_CTRL_LIST_INVALID: + case NVME_SC_BAD_ATTRIBUTES: + case NVME_SC_INVALID_PI: + case NVME_SC_INVALID_CTRL_ID: + case NVME_SC_INVALID_SEC_CTRL_STATE: + case NVME_SC_INVALID_CTRL_RESOURCES: + case NVME_SC_INVALID_RESOURCE_ID: + case NVME_SC_ANA_GROUP_ID_INVALID: + case NVME_SC_INSUFFICIENT_CAP: + case NVME_SC_INVALID_IOCS: + case NVME_SC_ID_UNAVAILABLE: + return EINVAL; + case NVME_SC_ABORT_LIMIT: + case NVME_SC_ASYNC_LIMIT: + case NVME_SC_NS_ATTACHMENT_LIMIT_EXCEEDED: + return EDQUOT; + case NVME_SC_FW_NEEDS_CONV_RESET: + case NVME_SC_FW_NEEDS_SUBSYS_RESET: + case NVME_SC_FW_NEEDS_MAX_TIME: + case NVME_SC_FW_NEEDS_RESET: + return ERESTART; + case NVME_SC_FEATURE_NOT_SAVEABLE: + case NVME_SC_FEATURE_NOT_CHANGEABLE: + case NVME_SC_FEATURE_NOT_PER_NS: + case NVME_SC_FW_ACTIVATE_PROHIBITED: + case NVME_SC_NS_IS_PRIVATE: + case NVME_SC_BP_WRITE_PROHIBITED: + case NVME_SC_READ_ONLY: + case NVME_SC_PMR_SAN_PROHIBITED: + return EPERM; + case NVME_SC_OVERLAPPING_RANGE: + case NVME_SC_NS_NOT_ATTACHED: + return ENOSPC; + case NVME_SC_NS_ALREADY_ATTACHED: + return EALREADY; + case NVME_SC_THIN_PROV_NOT_SUPP: + case NVME_SC_PROHIBIT_CMD_EXEC_NOT_SUPPORTED: + return EOPNOTSUPP; + case NVME_SC_ABORT_MISSING: + return EWOULDBLOCK; + case NVME_SC_SELF_TEST_IN_PROGRESS: + return EINPROGRESS; + } + + return EIO; +} + +static inline __u8 nvme_fabrics_status_to_errno(__u16 status) +{ + switch (status) { + case NVME_SC_CONNECT_FORMAT: + case NVME_SC_CONNECT_INVALID_PARAM: + case NVME_SC_DISCONNECT_INVALID_QTYPE: + return EINVAL; + case NVME_SC_CONNECT_CTRL_BUSY: + return EBUSY; + case NVME_SC_CONNECT_RESTART_DISC: + return ERESTART; + case NVME_SC_CONNECT_INVALID_HOST: + return ECONNREFUSED; + case NVME_SC_DISCOVERY_RESTART: + return EAGAIN; + case NVME_SC_AUTH_REQUIRED: + return EPERM; + } + + return EIO; +} + +__u8 nvme_status_to_errno(int status, bool fabrics) +{ + __u16 sc; + + if (!status) + return 0; + if (status < 0) + return errno; + + sc = nvme_status_code(status); + switch (nvme_status_code_type(status)) { + case NVME_SCT_GENERIC: + return nvme_generic_status_to_errno(sc); + case NVME_SCT_CMD_SPECIFIC: + if (fabrics) + return nvme_fabrics_status_to_errno(sc); + return nvme_cmd_specific_status_to_errno(sc); + default: + return EIO; + } +} + +static const char * const generic_status[] = { + [NVME_SC_SUCCESS] = "Successful Completion: The command completed without error", + [NVME_SC_INVALID_OPCODE] = "Invalid Command Opcode: A reserved coded value or an unsupported value in the command opcode field", + [NVME_SC_INVALID_FIELD] = "Invalid Field in Command: A reserved coded value or an unsupported value in a defined field", + [NVME_SC_CMDID_CONFLICT] = "Command ID Conflict: The command identifier is already in use", + [NVME_SC_DATA_XFER_ERROR] = "Data Transfer Error: Transferring the data or metadata associated with a command experienced an error", + [NVME_SC_POWER_LOSS] = "Commands Aborted due to Power Loss Notification: Indicates that the command was aborted due to a power loss notification", + [NVME_SC_INTERNAL] = "Internal Error: The command was not completed successfully due to an internal error", + [NVME_SC_ABORT_REQ] = "Command Abort Requested: The command was aborted due to an Abort command", + [NVME_SC_ABORT_QUEUE] = "Command Aborted due to SQ Deletion: The command was aborted due to a Delete I/O Submission Queue", + [NVME_SC_FUSED_FAIL] = "Command Aborted due to Failed Fused Command: The command was aborted due to the other command in a fused operation failing", + [NVME_SC_FUSED_MISSING] = "Command Aborted due to Missing Fused Command: The fused command was aborted due to the adjacent submission queue entry not containing a fused command", + [NVME_SC_INVALID_NS] = "Invalid Namespace or Format: The namespace or the format of that namespace is invalid", + [NVME_SC_CMD_SEQ_ERROR] = "Command Sequence Error: The command was aborted due to a protocol violation in a multi- command sequence", + [NVME_SC_SGL_INVALID_LAST] = "Invalid SGL Segment Descriptor: The command includes an invalid SGL Last Segment or SGL Segment descriptor", + [NVME_SC_SGL_INVALID_COUNT] = "Invalid Number of SGL Descriptors: There is an SGL Last Segment descriptor or an SGL Segment descriptor in a location other than the last descriptor of a segment based on the length indicated", + [NVME_SC_SGL_INVALID_DATA] = "Data SGL Length Invalid: The length of a Data SGL is too short or too long and the controller does not support SGL transfers longer than the amount of data to be transferred", + [NVME_SC_SGL_INVALID_METADATA] = "Metadata SGL Length Invalid: The length of a Metadata SGL is too short or too long and the controller does not support SGL transfers longer than the amount of data to be transferred", + [NVME_SC_SGL_INVALID_TYPE] = "SGL Descriptor Type Invalid: The type of an SGL Descriptor is a type that is not supported by the controller", + [NVME_SC_CMB_INVALID_USE] = "Invalid Use of Controller Memory Buffer: The attempted use of the Controller Memory Buffer is not supported by the controller", + [NVME_SC_PRP_INVALID_OFFSET] = "PRP Offset Invalid: The Offset field for a PRP entry is invalid", + [NVME_SC_AWU_EXCEEDED] = "Atomic Write Unit Exceeded: The length specified exceeds the atomic write unit size", + [NVME_SC_OP_DENIED] = "Operation Denied: The command was denied due to lack of access rights", + [NVME_SC_SGL_INVALID_OFFSET] = "SGL Offset Invalid: The offset specified in a descriptor is invalid", + [NVME_SC_HOSTID_FORMAT] = "Host Identifier Inconsistent Format: The NVM subsystem detected the simultaneous use of 64- bit and 128-bit Host Identifier values on different controllers", + [NVME_SC_KAT_EXPIRED] = "Keep Alive Timer Expired: The Keep Alive Timer expired", + [NVME_SC_KAT_INVALID] = "Keep Alive Timeout Invalid: The Keep Alive Timeout value specified is invalid", + [NVME_SC_CMD_ABORTED_PREMEPT] = "Command Aborted due to Preempt and Abort: The command was aborted due to a Reservation Acquire command", + [NVME_SC_SANITIZE_FAILED] = "Sanitize Failed: The most recent sanitize operation failed and no recovery action has been successfully completed", + [NVME_SC_SANITIZE_IN_PROGRESS] = "Sanitize In Progress: The requested function is prohibited while a sanitize operation is in progress", + [NVME_SC_SGL_INVALID_GRANULARITY] = "SGL Data Block Granularity Invalid: The Address alignment or Length granularity for an SGL Data Block descriptor is invalid", + [NVME_SC_CMD_IN_CMBQ_NOT_SUPP] = "Command Not Supported for Queue in CMB: The controller does not support Submission Queue in the Controller Memory Buffer or Completion Queue in the Controller Memory Buffer", + [NVME_SC_NS_WRITE_PROTECTED] = "Namespace is Write Protected: The command is prohibited while the namespace is write protected", + [NVME_SC_CMD_INTERRUPTED] = "Command Interrupted: Command processing was interrupted and the controller is unable to successfully complete the command", + [NVME_SC_TRAN_TPORT_ERROR] = "Transient Transport Error: A transient transport error was detected", + [NVME_SC_PROHIBITED_BY_CMD_AND_FEAT] = "Command Prohibited by Command and Feature Lockdown: The command was aborted due to command execution being prohibited by the Command and Feature Lockdown", + [NVME_SC_ADMIN_CMD_MEDIA_NOT_READY] = "Admin Command Media Not Ready: The Admin command requires access to media and the media is not ready", + [NVME_SC_LBA_RANGE] = "LBA Out of Range: The command references an LBA that exceeds the size of the namespace", + [NVME_SC_CAP_EXCEEDED] = "Capacity Exceeded: Execution of the command has caused the capacity of the namespace to be exceeded", + [NVME_SC_NS_NOT_READY] = "Namespace Not Ready: The namespace is not ready to be accessed", + [NVME_SC_RESERVATION_CONFLICT] = "Reservation Conflict: The command was aborted due to a conflict with a reservation held on the accessed namespace", + [NVME_SC_FORMAT_IN_PROGRESS] = "Format In Progress: A Format NVM command is in progress on the namespace", +}; + +static const char * const cmd_spec_status[] = { + [NVME_SC_CQ_INVALID] = "Completion Queue Invalid: The Completion Queue identifier specified in the command does not exist", + [NVME_SC_QID_INVALID] = "Invalid Queue Identifier: The creation of the I/O Completion Queue failed due to an invalid queue identifier specified as part of the command", + [NVME_SC_QUEUE_SIZE] = "Invalid Queue Size: The host attempted to create an I/O Completion Queue with an invalid number of entries", + [NVME_SC_ABORT_LIMIT] = "Abort Command Limit Exceeded: The number of concurrently outstanding Abort commands has exceeded the limit indicated in the Identify Controller data structure", + [NVME_SC_ABORT_MISSING] = "Abort Command Is Missing: The abort command is missing", + [NVME_SC_ASYNC_LIMIT] = "Asynchronous Event Request Limit Exceeded: The number of concurrently outstanding Asynchronous Event Request commands has been exceeded", + [NVME_SC_FIRMWARE_SLOT] = "Invalid Firmware Slot: The firmware slot indicated is invalid or read only", + [NVME_SC_FIRMWARE_IMAGE] = "Invalid Firmware Image: The firmware image specified for activation is invalid and not loaded by the controller", + [NVME_SC_INVALID_VECTOR] = "Invalid Interrupt Vector: The creation of the I/O Completion Queue failed due to an invalid interrupt vector specified as part of the command", + [NVME_SC_INVALID_LOG_PAGE] = "Invalid Log Page: The log page indicated is invalid", + [NVME_SC_INVALID_FORMAT] = "Invalid Format: The LBA Format specified is not supported", + [NVME_SC_FW_NEEDS_CONV_RESET] = "Firmware Activation Requires Conventional Reset: The firmware commit was successful, however, activation of the firmware image requires a conventional reset", + [NVME_SC_INVALID_QUEUE] = "Invalid Queue Deletion: Invalid I/O Completion Queue specified to delete", + [NVME_SC_FEATURE_NOT_SAVEABLE] = "Feature Identifier Not Saveable: The Feature Identifier specified does not support a saveable value", + [NVME_SC_FEATURE_NOT_CHANGEABLE] = "Feature Not Changeable: The Feature Identifier is not able to be changed", + [NVME_SC_FEATURE_NOT_PER_NS] = "Feature Not Namespace Specific: The Feature Identifier specified is not namespace specific", + [NVME_SC_FW_NEEDS_SUBSYS_RESET] = "Firmware Activation Requires NVM Subsystem Reset: The firmware commit was successful, however, activation of the firmware image requires an NVM Subsystem", + [NVME_SC_FW_NEEDS_RESET] = "Firmware Activation Requires Controller Level Reset: The firmware commit was successful; however, the image specified does not support being activated without a reset", + [NVME_SC_FW_NEEDS_MAX_TIME] = "Firmware Activation Requires Maximum Time Violation: The image specified if activated immediately would exceed the Maximum Time for Firmware Activation (MTFA) value reported in Identify Controller", + [NVME_SC_FW_ACTIVATE_PROHIBITED] = "Firmware Activation Prohibited: The image specified is being prohibited from activation by the controller for vendor specific reasons", + [NVME_SC_OVERLAPPING_RANGE] = "Overlapping Range: The downloaded firmware image has overlapping ranges", + [NVME_SC_NS_INSUFFICIENT_CAP] = "Namespace Insufficient Capacity: Creating the namespace requires more free space than is currently available", + [NVME_SC_NS_ID_UNAVAILABLE] = "Namespace Identifier Unavailable: The number of namespaces supported has been exceeded", + [NVME_SC_NS_ALREADY_ATTACHED] = "Namespace Already Attached: The controller is already attached to the namespace specified", + [NVME_SC_NS_IS_PRIVATE] = "Namespace Is Private: The namespace is private and is already attached to one controller", + [NVME_SC_NS_NOT_ATTACHED] = "Namespace Not Attached: The request to detach the controller could not be completed because the controller is not attached to the namespace", + [NVME_SC_THIN_PROV_NOT_SUPP] = "Thin Provisioning Not Supported: Thin provisioning is not supported by the controller", + [NVME_SC_CTRL_LIST_INVALID] = "Controller List Invalid: The controller list provided contains invalid controller ids", + [NVME_SC_SELF_TEST_IN_PROGRESS] = "Device Self-test In Progress: The controller or NVM subsystem already has a device self-test operation in process", + [NVME_SC_BP_WRITE_PROHIBITED] = "Boot Partition Write Prohibited: The command tried to modify a locked Boot Partition", + [NVME_SC_INVALID_CTRL_ID] = "Invalid Controller Identifier: An invalid controller id was specified", + [NVME_SC_INVALID_SEC_CTRL_STATE] = "Invalid Secondary Controller State: The requested secondary controller action is invalid based on the secondary and primary controllers current states", + [NVME_SC_INVALID_CTRL_RESOURCES] = "Invalid Number of Controller Resources: The specified number of Flexible Resources is invalid", + [NVME_SC_INVALID_RESOURCE_ID] = "Invalid Resource Identifier: At least one of the specified resource identifiers was invalid", + [NVME_SC_PMR_SAN_PROHIBITED] = "Sanitize Prohibited While Persistent Memory Region is Enabled", + [NVME_SC_ANA_GROUP_ID_INVALID] = "ANA Group Identifier Invalid: The specified ANA Group Identifier (ANAGRPID) is not supported in the submitted command", + [NVME_SC_ANA_ATTACH_FAILED] = "ANA Attach Failed: The controller is not attached to the namespace as a result of an ANA condition", + [NVME_SC_INSUFFICIENT_CAP] = "Insufficient Capacity: Requested operation requires more free space than is currently available", + [NVME_SC_NS_ATTACHMENT_LIMIT_EXCEEDED] = "Namespace Attachment Limit Exceeded: Attaching the ns to a controller causes max number of ns attachments allowed to be exceeded", + [NVME_SC_PROHIBIT_CMD_EXEC_NOT_SUPPORTED] = "Prohibition of Command Execution Not Supported", + [NVME_SC_IOCS_NOT_SUPPORTED] = "The I/O command set is not supported", + [NVME_SC_IOCS_NOT_ENABLED] = "The I/O command set is not enabled", + [NVME_SC_IOCS_COMBINATION_REJECTED] = "The I/O command set combination is rejected", + [NVME_SC_INVALID_IOCS] = "The I/O command set is invalid", + [NVME_SC_ID_UNAVAILABLE] = "Identifier Unavailable: The number of Endurance Groups or NVM Sets supported has been exceeded", + [NVME_SC_INVALID_DISCOVERY_INFO] = "Discovery Info Entry not applicable to selected entity", + [NVME_SC_ZONING_DATA_STRUCT_LOCKED] = "The requested Zoning data structure is locked on the CDC", + [NVME_SC_ZONING_DATA_STRUCT_NOTFND] = "The requested Zoning data structure does not exist on the CDC", + [NVME_SC_INSUFFICIENT_DISC_RES] = "Discovery Info entries exceed Discovery Controller's capacity", + [NVME_SC_REQSTD_FUNCTION_DISABLED] = "Fabric Zoning is not enabled on the CDC", + [NVME_SC_ZONEGRP_ORIGINATOR_INVLD] = "The NQN contained in the ZoneGroup Originator field does not match the Host NQN used by the DDC to connect to the CDC", +}; + +static const char * const nvm_status[] = { + [NVME_SC_BAD_ATTRIBUTES] = "Conflicting Attributes: The attributes specified in the command are conflicting", + [NVME_SC_INVALID_PI] = "Invalid Protection Information: The command's Protection Information Field settings are invalid for the namespace's Protection Information format", + [NVME_SC_READ_ONLY] = "Attempted Write to Read Only Range: The LBA range specified contains read-only blocks", + [NVME_SC_CMD_SIZE_LIMIT_EXCEEDED] = "Command Size Limit Exceeded", + [NVME_SC_ZNS_INVALID_OP_REQUEST] = "Invalid Zone Operation Request: The operation requested is invalid", + [NVME_SC_ZNS_ZRWA_RESOURCES_UNAVAILABLE] = "ZRWA Resources Unavailable: No ZRWAs are available", + [NVME_SC_ZNS_BOUNDARY_ERROR] = "Zoned Boundary Error: Invalid Zone Boundary crossing", + [NVME_SC_ZNS_FULL] = "Zone Is Full: The accessed zone is in ZSF:Full state", + [NVME_SC_ZNS_READ_ONLY] = "Zone Is Read Only: The accessed zone is in ZSRO:Read Only state", + [NVME_SC_ZNS_OFFLINE] = "Zone Is Offline: The access zone is in ZSO:Offline state", + [NVME_SC_ZNS_INVALID_WRITE] = "Zone Invalid Write: The write to zone was not at the write pointer offset", + [NVME_SC_ZNS_TOO_MANY_ACTIVE] = "Too Many Active Zones: The controller does not allow additional active zones", + [NVME_SC_ZNS_TOO_MANY_OPENS] = "Too Many Open Zones: The controller does not allow additional open zones", + [NVME_SC_ZNS_INVAL_TRANSITION] = "Invalid Zone State Transition: The request is not a valid zone state transition", +}; + +static const char * const nvmf_status[] = { + [NVME_SC_CONNECT_FORMAT] = "Incompatible Format: The NVM subsystem does not support the record format specified by the host", + [NVME_SC_CONNECT_CTRL_BUSY] = "Controller Busy: The controller is already associated with a host", + [NVME_SC_CONNECT_INVALID_PARAM] = "Connect Invalid Parameters: One or more of the command parameters", + [NVME_SC_CONNECT_RESTART_DISC] = "Connect Restart Discovery: The NVM subsystem requested is not available", + [NVME_SC_CONNECT_INVALID_HOST] = "Connect Invalid Host: The host is not allowed to establish an association to either any controller in the NVM subsystem or the specified controller", + [NVME_SC_DISCONNECT_INVALID_QTYPE] = "Invalid Queue Type: The command was sent on the wrong queue type", + [NVME_SC_DISCOVERY_RESTART] = "Discover Restart: The snapshot of the records is now invalid or out of date", + [NVME_SC_AUTH_REQUIRED] = "Authentication Required: NVMe in-band authentication is required and the queue has not yet been authenticated", +}; + +static const char * const media_status[] = { + [NVME_SC_WRITE_FAULT] = "Write Fault: The write data could not be committed to the media", + [NVME_SC_READ_ERROR] = "Unrecovered Read Error: The read data could not be recovered from the media", + [NVME_SC_GUARD_CHECK] = "End-to-end Guard Check Error: The command was aborted due to an end-to-end guard check failure", + [NVME_SC_APPTAG_CHECK] = "End-to-end Application Tag Check Error: The command was aborted due to an end-to-end application tag check failure", + [NVME_SC_REFTAG_CHECK] = "End-to-end Reference Tag Check Error: The command was aborted due to an end-to-end reference tag check failure", + [NVME_SC_COMPARE_FAILED] = "Compare Failure: The command failed due to a miscompare during a Compare command", + [NVME_SC_ACCESS_DENIED] = "Access Denied: Access to the namespace and/or LBA range is denied due to lack of access rights", + [NVME_SC_UNWRITTEN_BLOCK] = "Deallocated or Unwritten Logical Block: The command failed due to an attempt to read from or verify an LBA range containing a deallocated or unwritten logical block", + [NVME_SC_STORAGE_TAG_CHECK] = "End-to-End Storage Tag Check Error: The command was aborted due to an end-to-end storage tag check failure", +}; + +static const char * const path_status[] = { + [NVME_SC_ANA_INTERNAL_PATH_ERROR] = "Internal Path Error: An internal error specific to the controller processing the commmand prevented completion", + [NVME_SC_ANA_PERSISTENT_LOSS] = "Asymmetric Access Persistent Loss: The controller is in a persistent loss state with the requested namespace", + [NVME_SC_ANA_INACCESSIBLE] = "Asymmetric Access Inaccessible: The controller is in an inaccessible state with the requested namespace", + [NVME_SC_ANA_TRANSITION] = "Asymmetric Access Transition: The controller is currently transitioning states with the requested namespace", + [NVME_SC_CTRL_PATH_ERROR] = "Controller Pathing Error: A pathing error was detected by the controller", + [NVME_SC_HOST_PATH_ERROR] = "Host Pathing Error: A pathing error was detected by the host", + [NVME_SC_CMD_ABORTED_BY_HOST] = "Command Aborted By Host: The command was aborted as a result of host action", +}; + +#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0])) +#define ARGSTR(s, i) arg_str(s, ARRAY_SIZE(s), i) + +static const char *arg_str(const char * const *strings, + size_t array_size, size_t idx) +{ + if (idx < array_size && strings[idx]) + return strings[idx]; + return "unrecognized"; +} + +const char *nvme_status_to_string(int status, bool fabrics) +{ + const char *s = "Unknown status"; + __u16 sc, sct; + + if (status < 0) + return strerror(errno); + + sc = nvme_status_code(status); + sct = nvme_status_code_type(status); + + switch (sct) { + case NVME_SCT_GENERIC: + s = ARGSTR(generic_status, sc); + break; + case NVME_SCT_CMD_SPECIFIC: + if (sc < ARRAY_SIZE(cmd_spec_status)) + s = ARGSTR(cmd_spec_status, sc); + else if (fabrics) + s = ARGSTR(nvmf_status, sc); + else + s = ARGSTR(nvm_status, sc); + break; + case NVME_SCT_MEDIA: + s = ARGSTR(media_status, sc); + break; + case NVME_SCT_PATH: + s = ARGSTR(path_status, sc); + break; + case NVME_SCT_VS: + s = "Vendor Specific Status"; + break; + default: + break; + } + + return s; +} + +void nvme_init_copy_range(struct nvme_copy_range *copy, __u16 *nlbs, + __u64 *slbas, __u32 *eilbrts, __u32 *elbatms, + __u32 *elbats, __u16 nr) +{ + int i; + + for (i = 0; i < nr; i++) { + copy[i].nlb = cpu_to_le16(nlbs[i]); + copy[i].slba = cpu_to_le64(slbas[i]); + copy[i].eilbrt = cpu_to_le32(eilbrts[i]); + copy[i].elbatm = cpu_to_le16(elbatms[i]); + copy[i].elbat = cpu_to_le16(elbats[i]); + } +} + +void nvme_init_dsm_range(struct nvme_dsm_range *dsm, __u32 *ctx_attrs, + __u32 *llbas, __u64 *slbas, __u16 nr_ranges) +{ + int i; + + for (i = 0; i < nr_ranges; i++) { + dsm[i].cattr = cpu_to_le32(ctx_attrs[i]); + dsm[i].nlb = cpu_to_le32(llbas[i]); + dsm[i].slba = cpu_to_le64(slbas[i]); + } +} + +void nvme_init_ctrl_list(struct nvme_ctrl_list *cntlist, __u16 num_ctrls, + __u16 *ctrlist) +{ + int i; + + cntlist->num = cpu_to_le16(num_ctrls); + for (i = 0; i < num_ctrls; i++) + cntlist->identifier[i] = cpu_to_le16(ctrlist[i]); +} + +int nvme_get_feature_length(int fid, __u32 cdw11, __u32 *len) +{ + switch (fid) { + case NVME_FEAT_FID_LBA_RANGE: + *len = sizeof(struct nvme_lba_range_type); + break; + case NVME_FEAT_FID_AUTO_PST: + *len = sizeof(struct nvme_feat_auto_pst); + break; + case NVME_FEAT_FID_PLM_CONFIG: + *len = sizeof(struct nvme_plm_config); + break; + case NVME_FEAT_FID_TIMESTAMP: + *len = sizeof(struct nvme_timestamp); + break; + case NVME_FEAT_FID_HOST_BEHAVIOR: + *len = sizeof(struct nvme_feat_host_behavior); + break; + case NVME_FEAT_FID_HOST_ID: + *len = (cdw11 & 0x1) ? 16 : 8; + break; + case NVME_FEAT_FID_ARBITRATION: + case NVME_FEAT_FID_POWER_MGMT: + case NVME_FEAT_FID_TEMP_THRESH: + case NVME_FEAT_FID_ERR_RECOVERY: + case NVME_FEAT_FID_VOLATILE_WC: + case NVME_FEAT_FID_NUM_QUEUES: + case NVME_FEAT_FID_IRQ_COALESCE: + case NVME_FEAT_FID_IRQ_CONFIG: + case NVME_FEAT_FID_WRITE_ATOMIC: + case NVME_FEAT_FID_ASYNC_EVENT: + case NVME_FEAT_FID_HOST_MEM_BUF: + case NVME_FEAT_FID_KATO: + case NVME_FEAT_FID_HCTM: + case NVME_FEAT_FID_NOPSC: + case NVME_FEAT_FID_RRL: + case NVME_FEAT_FID_PLM_WINDOW: + case NVME_FEAT_FID_LBA_STS_INTERVAL: + case NVME_FEAT_FID_SANITIZE: + case NVME_FEAT_FID_ENDURANCE_EVT_CFG: + case NVME_FEAT_FID_SW_PROGRESS: + case NVME_FEAT_FID_RESV_MASK: + case NVME_FEAT_FID_RESV_PERSIST: + case NVME_FEAT_FID_WRITE_PROTECT: + *len = 0; + break; + case NVME_FEAT_FID_ENH_CTRL_METADATA: + case NVME_FEAT_FID_CTRL_METADATA: + case NVME_FEAT_FID_NS_METADATA: + *len = sizeof(struct nvme_host_metadata); + break; + default: + errno = EINVAL; + return -1; + } + return 0; +} + +int nvme_get_directive_receive_length(enum nvme_directive_dtype dtype, + enum nvme_directive_receive_doper doper, __u32 *len) +{ + switch (dtype) { + case NVME_DIRECTIVE_DTYPE_IDENTIFY: + switch (doper) { + case NVME_DIRECTIVE_RECEIVE_IDENTIFY_DOPER_PARAM: + *len = sizeof(struct nvme_id_directives); + return 0; + default: + errno = EINVAL; + return -1; + } + case NVME_DIRECTIVE_DTYPE_STREAMS: + switch (doper) { + case NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_PARAM: + *len = sizeof(struct nvme_streams_directive_params); + return 0; + case NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_STATUS: + *len = (128 * 1024) * sizeof(__le16); + return 0; + case NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_RESOURCE: + *len = 0; + return 0; + default: + errno = EINVAL; + return -1; + } + default: + errno = EINVAL; + return -1; + } +} + +static const char * const libnvme_status[] = { + [ENVME_CONNECT_RESOLVE] = "failed to resolve host", + [ENVME_CONNECT_ADDRFAM] = "unrecognized address family", + [ENVME_CONNECT_TRADDR] = "failed to get transport address", + [ENVME_CONNECT_TARG] = "no transport specified", + [ENVME_CONNECT_AARG] = "no transport address specified", + [ENVME_CONNECT_OPEN] = "failed to open nvme-fabrics device", + [ENVME_CONNECT_WRITE] = "failed to write to nvme-fabrics device", + [ENVME_CONNECT_READ] = "failed to read from nvme-fabrics device", + [ENVME_CONNECT_PARSE] = "failed to parse ctrl info", + [ENVME_CONNECT_INVAL_TR] = "invalid transport type", + [ENVME_CONNECT_LOOKUP_SUBSYS_NAME] = "failed to lookup subsystem name", + [ENVME_CONNECT_LOOKUP_SUBSYS] = "failed to lookup subsystem", +}; + +const char *nvme_errno_to_string(int status) +{ + const char *s = ARGSTR(libnvme_status, status); + + return s; +} + +char *hostname2traddr(struct nvme_root *r, const char *traddr) +{ + struct addrinfo *host_info, hints = {.ai_family = AF_UNSPEC}; + char addrstr[NVMF_TRADDR_SIZE]; + const char *p; + char *ret_traddr = NULL; + int ret; + + ret = getaddrinfo(traddr, NULL, &hints, &host_info); + if (ret) { + nvme_msg(r, LOG_ERR, "failed to resolve host %s info\n", + traddr); + return NULL; + } + + switch (host_info->ai_family) { + case AF_INET: + p = inet_ntop(host_info->ai_family, + &(((struct sockaddr_in *)host_info->ai_addr)->sin_addr), + addrstr, NVMF_TRADDR_SIZE); + break; + case AF_INET6: + p = inet_ntop(host_info->ai_family, + &(((struct sockaddr_in6 *)host_info->ai_addr)->sin6_addr), + addrstr, NVMF_TRADDR_SIZE); + break; + default: + nvme_msg(r, LOG_ERR, "unrecognized address family (%d) %s\n", + host_info->ai_family, traddr); + goto free_addrinfo; + } + + if (!p) { + nvme_msg(r, LOG_ERR, "failed to get traddr for %s\n", + traddr); + goto free_addrinfo; + } + ret_traddr = strdup(addrstr); + +free_addrinfo: + freeaddrinfo(host_info); + return ret_traddr; +} + +char *startswith(const char *s, const char *prefix) +{ + size_t l; + + l = strlen(prefix); + if (!strncmp(s, prefix, l)) + return (char *)s + l; + + return NULL; +} + +char *kv_strip(char *kv) +{ + char *s; + + kv[strcspn(kv, "\n\r")] = '\0'; + + /* Remove leading newline and spaces */ + kv += strspn(kv, " \t\n\r"); + + /* Skip comments and empty lines */ + if (*kv == '#' || *kv == '\0') { + *kv = '\0'; + return kv; + } + + /* Remove trailing newline chars */ + kv[strcspn(kv, "\n\r")] = '\0'; + + /* Delete trailing comments (including spaces/tabs that precede the #)*/ + s = &kv[strcspn(kv, "#")]; + *s-- = '\0'; + while ((s >= kv) && ((*s == ' ') || (*s == '\t'))) { + *s-- = '\0'; + } + + return kv; +} + +char *kv_keymatch(const char *kv, const char *key) +{ + char *value; + + value = startswith(kv, key); + if (value) { + /* Make sure key is a whole word. I.e. it should be + * followed by spaces, tabs, or a equal sign. Skip + * leading spaces, tabs, and equal sign (=) */ + switch (*value) { + case ' ': + case '\t': + case '=': + value += strspn(value, " \t="); + return value; + default: ; + } + } + + return NULL; +} + +/** + * read_file - read contents of file into @buffer. + * @fname: File name + * @buffer: Where to save file's contents + * @bufsz: Size of @buffer. On success, @bufsz gets decremented by the + * number of characters that were writtent to @buffer. + * + * Return: The number of characters read. If the file cannot be opened or + * nothing is read from the file, then this function returns 0. + */ +static size_t read_file(const char * fname, char *buffer, size_t *bufsz) +{ + char *p; + FILE *file; + size_t len; + + file = fopen(fname, "re"); + if (!file) + return 0; + + p = fgets(buffer, *bufsz, file); + fclose(file); + + if (!p) + return 0; + + /* Strip unwanted trailing chars */ + len = strcspn(buffer, " \t\n\r"); + *bufsz -= len; + + return len; +} + +static size_t copy_value(char *buf, size_t buflen, const char *value) +{ + size_t val_len; + + memset(buf, 0, buflen); + + /* Remove leading " */ + if (value[0] == '"') + value++; + + /* Remove trailing " */ + val_len = strcspn(value, "\""); + + memcpy(buf, value, MIN(val_len, buflen-1)); + + return val_len; +} + +size_t get_entity_name(char *buffer, size_t bufsz) +{ + size_t len = !gethostname(buffer, bufsz) ? strlen(buffer) : 0; + + /* Fill the rest of buffer with zeros */ + memset(&buffer[len], '\0', bufsz-len); + + return len; +} + +size_t get_entity_version(char *buffer, size_t bufsz) +{ + FILE *file; + size_t num_bytes = 0; + + /* /proc/sys/kernel/ostype typically contains the string "Linux" */ + num_bytes += read_file("/proc/sys/kernel/ostype", + &buffer[num_bytes], &bufsz); + + /* /proc/sys/kernel/osrelease contains the Linux + * version (e.g. 5.8.0-63-generic) + */ + buffer[num_bytes++] = ' '; /* Append a space */ + num_bytes += read_file("/proc/sys/kernel/osrelease", + &buffer[num_bytes], &bufsz); + + /* /etc/os-release contains Key-Value pairs. We only care about the key + * PRETTY_NAME, which contains the Distro's version. For example: + * "SUSE Linux Enterprise Server 15 SP4", "Ubuntu 20.04.3 LTS", or + * "Fedora Linux 35 (Server Edition)" + */ + file = fopen("/etc/os-release", "re"); + if (file) { + char name[64] = {0}; + size_t name_len = 0; + char ver_id[64] = {0}; + size_t ver_id_len = 0; + char line[LINE_MAX]; + char *p; + char *s; + + /* Read key-value pairs one line at a time */ + while ((!name_len || !ver_id_len) && + (p = fgets(line, sizeof(line), file)) != NULL) { + /* Clean up string by removing leading/trailing blanks + * and new line characters. Also eliminate trailing + * comments, if any. + */ + p = kv_strip(p); + + /* Empty string? */ + if (*p == '\0') + continue; + + s = kv_keymatch(p, "NAME"); + if (s) + name_len = copy_value(name, sizeof(name), s); + + s = kv_keymatch(p, "VERSION_ID"); + if (s) + ver_id_len = copy_value(ver_id, sizeof(ver_id), s); + } + fclose(file); + + if (name_len) { + /* Append a space */ + buffer[num_bytes++] = ' '; + name_len = MIN(name_len, bufsz); + memcpy(&buffer[num_bytes], name, name_len); + bufsz -= name_len; + num_bytes += name_len; + } + + if (ver_id_len) { + /* Append a space */ + buffer[num_bytes++] = ' '; + ver_id_len = MIN(ver_id_len, bufsz); + memcpy(&buffer[num_bytes], ver_id, ver_id_len); + bufsz -= ver_id_len; + num_bytes += ver_id_len; + } + } + + /* Fill the rest of buffer with zeros */ + memset(&buffer[num_bytes], '\0', bufsz); + + return num_bytes; +} + +struct nvmf_ext_attr *nvmf_exat_ptr_next(struct nvmf_ext_attr *p) +{ + return (struct nvmf_ext_attr *) + ((uintptr_t)p + (ptrdiff_t)nvmf_exat_size(le16_to_cpu(p->exatlen))); +} diff --git a/src/nvme/util.h b/src/nvme/util.h new file mode 100644 index 0000000..277b857 --- /dev/null +++ b/src/nvme/util.h @@ -0,0 +1,535 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/* + * This file is part of libnvme. + * Copyright (c) 2020 Western Digital Corporation or its affiliates. + * + * Authors: Keith Busch <keith.busch@wdc.com> + * Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com> + */ +#ifndef _LIBNVME_UTIL_H +#define _LIBNVME_UTIL_H + +#include "types.h" + +/** + * DOC: util.h + * + * libnvme utility functions + */ + +/** + * enum nvme_connect_err - nvme connect error codes + * @ENVME_CONNECT_RESOLVE: failed to resolve host + * @ENVME_CONNECT_ADDRFAM: unrecognized address family + * @ENVME_CONNECT_TRADDR: failed to get traddr + * @ENVME_CONNECT_TARG: need a transport (-t) argument + * @ENVME_CONNECT_AARG: need a address (-a) argument + * @ENVME_CONNECT_OPEN: failed to open nvme-fabrics device + * @ENVME_CONNECT_WRITE: failed to write to nvme-fabrics device + * @ENVME_CONNECT_READ: failed to read from nvme-fabrics device + * @ENVME_CONNECT_PARSE: failed to parse ctrl info + * @ENVME_CONNECT_INVAL_TR: invalid transport type + * @ENVME_CONNECT_LOOKUP_SUBSYS_NAME: failed to lookup subsystem name + * @ENVME_CONNECT_LOOKUP_SUBSYS: failed to lookup subsystem + */ +enum nvme_connect_err { + ENVME_CONNECT_RESOLVE = 1000, + ENVME_CONNECT_ADDRFAM, + ENVME_CONNECT_TRADDR, + ENVME_CONNECT_TARG, + ENVME_CONNECT_AARG, + ENVME_CONNECT_OPEN, + ENVME_CONNECT_WRITE, + ENVME_CONNECT_READ, + ENVME_CONNECT_PARSE, + ENVME_CONNECT_INVAL_TR, + ENVME_CONNECT_LOOKUP_SUBSYS_NAME, + ENVME_CONNECT_LOOKUP_SUBSYS, +}; + +/** + * nvme_status_to_errno() - Converts nvme return status to errno + * @status: Return status from an nvme passthrough commmand + * @fabrics: Set to true if &status is to a fabrics target. + * + * Return: An errno representing the nvme status if it is an nvme status field, + * or unchanged status is < 0 since errno is already set. + */ +__u8 nvme_status_to_errno(int status, bool fabrics); + +/** + * nvme_status_to_string() - Returns string describing nvme return status. + * @status: Return status from an nvme passthrough commmand + * @fabrics: Set to true if &status is to a fabrics target. + * + * Return: String representation of the nvme status if it is an nvme status field, + * or a standard errno string if status is < 0. + */ +const char *nvme_status_to_string(int status, bool fabrics); + +/** + * nvme_errno_to_string() - Returns string describing nvme connect failures + * @err: Returned error code from nvme_add_ctrl() + * + * Return: String representation of the nvme connect error codes + */ +const char *nvme_errno_to_string(int err); + +/** + * nvme_init_ctrl_list() - Initialize an nvme_ctrl_list structure from an array. + * @cntlist: The controller list structure to initialize + * @num_ctrls: The number of controllers in the array, &ctrlist. + * @ctrlist: An array of controller identifiers in CPU native endian. + * + * This is intended to be used with any command that takes a controller list + * argument. See nvme_ns_attach_ctrls() and nvme_ns_detach(). + */ +void nvme_init_ctrl_list(struct nvme_ctrl_list *cntlist, __u16 num_ctrls, + __u16 *ctrlist); + +/** + * nvme_init_dsm_range() - Constructs a data set range structure + * @dsm: DSM range array + * @ctx_attrs: Array of context attributes + * @llbas: Array of length in logical blocks + * @slbas: Array of starting logical blocks + * @nr_ranges: The size of the dsm arrays + * + * Each array must be the same size of size 'nr_ranges'. This is intended to be + * used with constructing a payload for nvme_dsm(). + * + * Return: The nvme command status if a response was received or -errno + * otherwise. + */ +void nvme_init_dsm_range(struct nvme_dsm_range *dsm, __u32 *ctx_attrs, + __u32 *llbas, __u64 *slbas, __u16 nr_ranges); + +/** + * nvme_init_copy_range() - Constructs a copy range structure + * @copy: Copy range array + * @nlbs: Number of logical blocks + * @slbas: Starting LBA + * @eilbrts: Expected initial logical block reference tag + * @elbatms: Expected logical block application tag mask + * @elbats: Expected logical block application tag + * @nr: Number of descriptors to construct + */ +void nvme_init_copy_range(struct nvme_copy_range *copy, __u16 *nlbs, + __u64 *slbas, __u32 *eilbrts, __u32 *elbatms, + __u32 *elbats, __u16 nr); + +/** + * nvme_get_feature_length() - Retreive the command payload length for a + * specific feature identifier + * @fid: Feature identifier, see &enum nvme_features_id. + * @cdw11: The cdw11 value may affect the transfer (only known fid is + * %NVME_FEAT_FID_HOST_ID) + * @len: On success, set to this features payload length in bytes. + * + * Return: 0 on success, -1 with errno set to EINVAL if the function did not + * recognize &fid. + */ +int nvme_get_feature_length(int fid, __u32 cdw11, __u32 *len); + +/** + * nvme_get_directive_receive_length() - + * @dtype: Directive type, see &enum nvme_directive_dtype + * @doper: Directive receive operation, see &enum nvme_directive_receive_doper + * @len: On success, set to this directives payload length in bytes. + * + * Return: 0 on success, -1 with errno set to EINVAL if the function did not + * recognize &dtype or &doper. + */ +int nvme_get_directive_receive_length(enum nvme_directive_dtype dtype, + enum nvme_directive_receive_doper doper, __u32 *len); + +#define NVME_FEAT_ARB_BURST(v) NVME_GET(v, FEAT_ARBITRATION_BURST) +#define NVME_FEAT_ARB_LPW(v) NVME_GET(v, FEAT_ARBITRATION_LPW) +#define NVME_FEAT_ARB_MPW(v) NVME_GET(v, FEAT_ARBITRATION_MPW) +#define NVME_FEAT_ARB_HPW(v) NVME_GET(v, FEAT_ARBITRATION_HPW) + +static inline void nvme_feature_decode_arbitration(__u32 value, __u8 *ab, + __u8 *lpw, __u8 *mpw, + __u8 *hpw) +{ + *ab = NVME_FEAT_ARB_BURST(value); + *lpw = NVME_FEAT_ARB_LPW(value); + *mpw = NVME_FEAT_ARB_MPW(value); + *hpw = NVME_FEAT_ARB_HPW(value); +}; + +#define NVME_FEAT_PM_PS(v) NVME_GET(v, FEAT_PWRMGMT_PS) +#define NVME_FEAT_PM_WH(v) NVME_GET(v, FEAT_PWRMGMT_WH) + +static inline void nvme_feature_decode_power_mgmt(__u32 value, __u8 *ps, + __u8 *wh) +{ + *ps = NVME_FEAT_PM_PS(value); + *wh = NVME_FEAT_PM_WH(value); +} + +#define NVME_FEAT_LBAR_NR(v) NVME_GET(v, FEAT_LBAR_NR) + +static inline void nvme_feature_decode_lba_range(__u32 value, __u8 *num) +{ + *num = NVME_FEAT_LBAR_NR(value); +} + +#define NVME_FEAT_TT_TMPTH(v) NVME_GET(v, FEAT_TT_TMPTH) +#define NVME_FEAT_TT_TMPSEL(v) NVME_GET(v, FEAT_TT_TMPSEL) +#define NVME_FEAT_TT_THSEL(v) NVME_GET(v, FEAT_TT_THSEL) + +static inline void nvme_feature_decode_temp_threshold(__u32 value, __u16 *tmpth, + __u8 *tmpsel, __u8 *thsel) +{ + *tmpth = NVME_FEAT_TT_TMPTH(value); + *tmpsel = NVME_FEAT_TT_TMPSEL(value); + *thsel = NVME_FEAT_TT_THSEL(value); +} + +#define NVME_FEAT_ER_TLER(v) NVME_GET(v, FEAT_ERROR_RECOVERY_TLER) +#define NVME_FEAT_ER_DULBE(v) NVME_GET(v, FEAT_ERROR_RECOVERY_DULBE) + +static inline void nvme_feature_decode_error_recovery(__u32 value, __u16 *tler, + bool *dulbe) +{ + *tler = NVME_FEAT_ER_TLER(value); + *dulbe = NVME_FEAT_ER_DULBE(value); +} + +#define NVME_FEAT_VWC_WCE(v) NVME_GET(v, FEAT_VWC_WCE) + +static inline void nvme_feature_decode_volatile_write_cache(__u32 value, + bool *wce) +{ + *wce = NVME_FEAT_VWC_WCE(value); +} + +#define NVME_FEAT_NRQS_NSQR(v) NVME_GET(v, FEAT_NRQS_NSQR) +#define NVME_FEAT_NRQS_NCQR(v) NVME_GET(v, FEAT_NRQS_NCQR) + +static inline void nvme_feature_decode_number_of_queues(__u32 value, + __u16 *nsqr, + __u16 *ncqr) +{ + *nsqr = NVME_FEAT_NRQS_NSQR(value); + *ncqr = NVME_FEAT_NRQS_NCQR(value); +} + +#define NVME_FEAT_IRQC_THR(v) NVME_GET(v, FEAT_IRQC_THR) +#define NVME_FEAT_IRQC_TIME(v) NVME_GET(v, FEAT_IRQC_TIME) + +static inline void nvme_feature_decode_interrupt_coalescing(__u32 value, + __u8 *thr, + __u8 *time) +{ + *thr = NVME_FEAT_IRQC_THR(value); + *time = NVME_FEAT_IRQC_TIME(value); +} + +#define NVME_FEAT_ICFG_IV(v) NVME_GET(v, FEAT_ICFG_IV) +#define NVME_FEAT_ICFG_CD(v) NVME_GET(v, FEAT_ICFG_CD) + +static inline void nvme_feature_decode_interrupt_config(__u32 value, __u16 *iv, + bool *cd) +{ + *iv = NVME_FEAT_ICFG_IV(value); + *cd = NVME_FEAT_ICFG_CD(value); +} + +#define NVME_FEAT_WA_DN(v) NVME_GET(v, FEAT_WA_DN) + +static inline void nvme_feature_decode_write_atomicity(__u32 value, bool *dn) +{ + *dn = NVME_FEAT_WA_DN(value); +} + +#define NVME_FEAT_AE_SMART(v) NVME_GET(v, FEAT_AE_SMART) +#define NVME_FEAT_AE_NAN(v) NVME_GET(v, FEAT_AE_NAN) +#define NVME_FEAT_AE_FW(v) NVME_GET(v, FEAT_AE_FW) +#define NVME_FEAT_AE_TELEM(v) NVME_GET(v, FEAT_AE_TELEM) +#define NVME_FEAT_AE_ANA(v) NVME_GET(v, FEAT_AE_ANA) +#define NVME_FEAT_AE_PLA(v) NVME_GET(v, FEAT_AE_PLA) +#define NVME_FEAT_AE_LBAS(v) NVME_GET(v, FEAT_AE_LBAS) +#define NVME_FEAT_AE_EGA(v) NVME_GET(v, FEAT_AE_EGA) + +static inline void nvme_feature_decode_async_event_config(__u32 value, + __u8 *smart, bool *nan, bool *fw, bool *telem, + bool *ana, bool *pla, bool *lbas, bool *ega) +{ + *smart = NVME_FEAT_AE_SMART(value); + *nan = NVME_FEAT_AE_NAN(value); + *fw = NVME_FEAT_AE_FW(value); + *telem = NVME_FEAT_AE_TELEM(value); + *ana = NVME_FEAT_AE_ANA(value); + *pla = NVME_FEAT_AE_PLA(value); + *lbas = NVME_FEAT_AE_LBAS(value); + *ega = NVME_FEAT_AE_EGA(value); +} + +#define NVME_FEAT_APST_APSTE(v) NVME_GET(v, FEAT_APST_APSTE) + +static inline void nvme_feature_decode_auto_power_state(__u32 value, + bool *apste) +{ + *apste = NVME_FEAT_APST_APSTE(value); +} + +#define NVME_FEAT_HMEM_EHM(v) NVME_GET(v, FEAT_HMEM_EHM) + +static inline void nvme_feature_decode_host_memory_buffer(__u32 value, bool *ehm) +{ + *ehm = NVME_FEAT_HMEM_EHM(value); +} + +#define NVME_FEAT_HCTM_TMT2(v) NVME_GET(v, FEAT_HCTM_TMT2) +#define NVME_FEAT_HCTM_TMT1(v) NVME_GET(v, FEAT_HCTM_TMT1) + +static inline void nvme_feature_decode_host_thermal_mgmt(__u32 value, + __u16 *tmt2, + __u16 *tmt1) +{ + *tmt2 = NVME_FEAT_HCTM_TMT2(value); + *tmt1 = NVME_FEAT_HCTM_TMT1(value); +} + +#define NVME_FEAT_NOPS_NOPPME(v) NVME_GET(v, FEAT_NOPS_NOPPME) + +static inline void nvme_feature_decode_non_op_power_config(__u32 value, + bool *noppme) +{ + *noppme = NVME_FEAT_NOPS_NOPPME(value); +} + +#define NVME_FEAT_RRL_RRL(v) NVME_GET(v, FEAT_RRL_RRL) + +static inline void nvme_feature_decode_read_recovery_level_config(__u32 value, + __u8 *rrl) +{ + *rrl = NVME_FEAT_RRL_RRL(value); +} + +#define NVME_FEAT_PLM_PLME(v) NVME_GET(v, FEAT_PLM_PLME) + +static inline void nvme_feature_decode_predictable_latency_mode_config(__u32 value, + bool *plme) +{ + *plme = NVME_FEAT_PLM_PLME(value); +} + +#define NVME_FEAT_PLMW_WS(v) NVME_GET(v, FEAT_PLMW_WS) + +static inline void nvme_feature_decode_predictable_latency_mode_window(__u32 value, + __u8 *ws) +{ + *ws = NVME_FEAT_PLMW_WS(value); +} + +#define NVME_FEAT_LBAS_LSIRI(v) NVME_GET(v, FEAT_LBAS_LSIRI) +#define NVME_FEAT_LBAS_LSIPI(v) NVME_GET(v, FEAT_LBAS_LSIPI) + +static inline void nvme_feature_decode_lba_status_attributes(__u32 value, + __u16 *lsiri, + __u16 *lsipi) +{ + *lsiri = NVME_FEAT_LBAS_LSIRI(value); + *lsipi = NVME_FEAT_LBAS_LSIPI(value); +} + +#define NVME_FEAT_SC_NODRM(v) NVME_GET(v, FEAT_SC_NODRM) + +static inline void nvme_feature_decode_sanitize_config(__u32 value, bool *nodrm) +{ + *nodrm = NVME_FEAT_SC_NODRM(value); +} + +#define NVME_FEAT_EG_ENDGID(v) NVME_GET(v, FEAT_EG_ENDGID) +#define NVME_FEAT_EG_EGCW(v) NVME_GET(v, FEAT_EG_EGCW) + +static inline void nvme_feature_decode_endurance_group_event_config(__u32 value, + __u16 *endgid, __u8 *endgcw) +{ + *endgid = NVME_FEAT_EG_ENDGID(value); + *endgcw = NVME_FEAT_EG_EGCW(value); +} + +#define NVME_FEAT_SPM_PBSLC(v) NVME_GET(v, FEAT_SPM_PBSLC) + +static inline void nvme_feature_decode_software_progress_marker(__u32 value, + __u8 *pbslc) +{ + *pbslc = NVME_FEAT_SPM_PBSLC(value); +} + +#define NVME_FEAT_HOSTID_EXHID(v) NVME_GET(v, FEAT_HOSTID_EXHID) + +static inline void nvme_feature_decode_host_identifier(__u32 value, bool *exhid) +{ + *exhid = NVME_FEAT_HOSTID_EXHID(value); +} + +#define NVME_FEAT_RM_REGPRE(v) NVME_GET(v, FEAT_RM_REGPRE) +#define NVME_FEAT_RM_RESREL(v) NVME_GET(v, FEAT_RM_RESREL) +#define NVME_FEAT_RM_RESPRE(v) NVME_GET(v, FEAT_RM_RESPRE) + +static inline void nvme_feature_decode_reservation_notification(__u32 value, + bool *regpre, + bool *resrel, + bool *respre) +{ + *regpre = NVME_FEAT_RM_REGPRE(value); + *resrel = NVME_FEAT_RM_RESREL(value); + *respre = NVME_FEAT_RM_RESPRE(value); +} + +#define NVME_FEAT_RP_PTPL(v) NVME_GET(v, FEAT_RP_PTPL) + +static inline void nvme_feature_decode_reservation_persistance(__u32 value, + bool *ptpl) +{ + *ptpl = NVME_FEAT_RP_PTPL(value); +} + +#define NVME_FEAT_WP_WPS(v) NVME_GET(v, FEAT_WP_WPS) + +static inline void nvme_feature_decode_namespace_write_protect(__u32 value, + __u8 *wps) +{ + *wps = NVME_FEAT_WP_WPS(value); +} + +static inline void nvme_id_ns_flbas_to_lbaf_inuse(__u8 flbas, __u8 *lbaf_inuse) +{ + *lbaf_inuse = (((flbas & NVME_NS_FLBAS_HIGHER_MASK) >> 1) \ + | (flbas & NVME_NS_FLBAS_LOWER_MASK)); +} + +struct nvme_root; + +char *hostname2traddr(struct nvme_root *r, const char *traddr); + +/** + * get_entity_name - Get Entity Name (ENAME). + * @buffer: The buffer where the ENAME will be saved as an ASCII string. + * @bufsz: The size of @buffer. + * + * Per TP8010, ENAME is defined as the name associated with the host (i.e. + * hostname). + * + * Return: Number of characters copied to @buffer. + */ +size_t get_entity_name(char *buffer, size_t bufsz); + +/** + * get_entity_version - Get Entity Version (EVER). + * @buffer: The buffer where the EVER will be saved as an ASCII string. + * @bufsz: The size of @buffer. + * + * EVER is defined as the operating system name and version as an ASCII + * string. This function reads different files from the file system and + * builds a string as follows: [os type] [os release] [distro release] + * + * E.g. "Linux 5.17.0-rc1 SLES 15.4" + * + * Return: Number of characters copied to @buffer. + */ +size_t get_entity_version(char *buffer, size_t bufsz); + +/** + * kv_strip - Strip blanks from key value string + * @kv: The key-value string to strip + * + * Strip leading/trailing blanks as well as trailing comments from the + * Key=Value string pointed to by @kv. + * + * Return: A pointer to the stripped string. Note that the original string, + * @kv, gets modified. + */ +char *kv_strip(char *kv); + +/** + * kv_keymatch - Look for key in key value string + * @kv: The key=value string to search for the presence of @key + * @key: The key to look for + * + * Look for @key in the Key=Value pair pointed to by @k and return a + * pointer to the Value if @key is found. + * + * Check if @kv starts with @key. If it does then make sure that we + * have a whole-word match on the @key, and if we do, return a pointer + * to the first character of value (i.e. skip leading spaces, tabs, + * and equal sign) + * + * Return: A pointer to the first character of "value" if a match is found. + * NULL otherwise. + */ +char *kv_keymatch(const char *kv, const char *key); + +/** + * startswith - Checks that a string starts with a given prefix. + * @s: The string to check + * @prefix: A string that @s could be starting with + * + * Return: If @s starts with @prefix, then return a pointer within @s at + * the first character after the matched @prefix. NULL otherwise. + */ +char* startswith(const char *s, const char *prefix); + +#define __round_mask(val, mult) ((__typeof__(val))((mult)-1)) + +/** + * round_up - Round a value @val to the next multiple specified by @mult. + * @val: Value to round + * @mult: Multiple to round to. + * + * usage: int x = round_up(13, sizeof(__u32)); // 13 -> 16 + */ +#define round_up(val, mult) ((((val)-1) | __round_mask((val), (mult)))+1) + +/** + * nvmf_exat_len() - Return length rounded up by 4 + * @val_len: Value lenght + * + * Return the size in bytes, rounded to a multiple of 4 (e.g., size of + * __u32), of the buffer needed to hold the exat value of size + * @val_len. + * + * Return: Lenght rounded up by 4 + */ +static inline __u16 nvmf_exat_len(size_t val_len) +{ + return (__u16)round_up(val_len, sizeof(__u32)); +} + +/** + * nvmf_exat_size - Return min algined size to hold value + * @val_len: This is the length of the data to be copied to the "exatval" + * field of a "struct nvmf_ext_attr". + * + * Return the size of the "struct nvmf_ext_attr" needed to hold + * a value of size @val_len. + * + * Return: The size in bytes, rounded to a multiple of 4 (i.e. size of + * __u32), of the "struct nvmf_ext_attr" required to hold a string of + * length @val_len. + */ +static inline __u16 nvmf_exat_size(size_t val_len) +{ + return (__u16)(sizeof(struct nvmf_ext_attr) + nvmf_exat_len(val_len)); +} + +/** + * nvmf_exat_ptr_next - Increment @p to the next element in the array. + * @p: Pointer to an element of an array of "struct nvmf_ext_attr". + * + * Extended attributes are saved to an array of "struct nvmf_ext_attr" + * where each element of the array is of variable size. In order to + * move to the next element in the array one must increment the + * pointer to the current element (@p) by the size of the current + * element. + * + * Return: Pointer to the next element in the array. + */ +struct nvmf_ext_attr *nvmf_exat_ptr_next(struct nvmf_ext_attr *p); + +#endif /* _LIBNVME_UTIL_H */ diff --git a/subprojects/json-c.wrap b/subprojects/json-c.wrap new file mode 100644 index 0000000..4ce9ab8 --- /dev/null +++ b/subprojects/json-c.wrap @@ -0,0 +1,12 @@ +[wrap-file] +directory = json-c-0.15 +source_url = https://s3.amazonaws.com/json-c_releases/releases/json-c-0.15.tar.gz +source_filename = json-c-0.15.tar.gz +source_hash = b8d80a1ddb718b3ba7492916237bbf86609e9709fb007e7f7d4322f02341a4c6 +patch_filename = json-c_0.15-2_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/json-c_0.15-2/get_patch +patch_hash = 2c5c95cf463804ac61309930c76ba9f57b157fef6247d1c6da4395b31a5bfac7 + +[provide] +json-c = json_c_dep + diff --git a/subprojects/openssl.wrap b/subprojects/openssl.wrap new file mode 100644 index 0000000..ed29373 --- /dev/null +++ b/subprojects/openssl.wrap @@ -0,0 +1,14 @@ +[wrap-file] +directory = openssl-1.1.1l +source_url = https://www.openssl.org/source/openssl-1.1.1l.tar.gz +source_filename = openssl-1.1.1l.tar.gz +source_hash = 0b7a3e5e59c34827fe0c3a74b7ec8baef302b98fa80088d7f9153aa16fa76bd1 +patch_filename = openssl_1.1.1l-3_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/openssl_1.1.1l-3/get_patch +patch_hash = a0cb8285cda3ae0e1898b4e88427c19bf245184259f41395010182655f9f8ce6 + +[provide] +libcrypto = libcrypto_dep +libssl = libssl_dep +openssl = openssl_dep + diff --git a/test/cpp.cc b/test/cpp.cc new file mode 100644 index 0000000..3d0a7d2 --- /dev/null +++ b/test/cpp.cc @@ -0,0 +1,66 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/** + * This file is part of libnvme. + * Copyright (c) 2020 Western Digital Corporation or its affiliates. + * + * Authors: Keith Busch <keith.busch@wdc.com> + */ + +#include <iostream> +#include <libnvme.h> + +int main() +{ + nvme_root_t r; + nvme_host_t h; + nvme_subsystem_t s; + nvme_ctrl_t c; + nvme_path_t p; + nvme_ns_t n; + + r = nvme_scan(NULL); + if (!r) + return -1; + + nvme_for_each_host(r, h) { + nvme_for_each_subsystem(h, s) { + std::cout << nvme_subsystem_get_name(s) + << " - NQN=" << nvme_subsystem_get_nqn(s) + << "\n"; + nvme_subsystem_for_each_ctrl(s, c) { + std::cout << " `- " << nvme_ctrl_get_name(c) + << " " << nvme_ctrl_get_transport(c) + << " " << nvme_ctrl_get_address(c) + << " " << nvme_ctrl_get_state(c) + << "\n"; + nvme_ctrl_for_each_ns(c, n) { + std::cout << " `- " + << nvme_ns_get_name(n) + << "lba size:" + << nvme_ns_get_lba_size(n) + << " lba max:" + << nvme_ns_get_lba_count(n) + << "\n"; + } + nvme_ctrl_for_each_path(c, p) { + std::cout << " `- " + << nvme_path_get_name(p) + << " " + << nvme_path_get_ana_state(p) + << "\n"; + } + } + nvme_subsystem_for_each_ns(s, n) { + std::cout << " `- " << nvme_ns_get_name(n) + << "lba size:" + << nvme_ns_get_lba_size(n) + << " lba max:" + << nvme_ns_get_lba_count(n) << "\n"; + } + } + } + std::cout << "\n"; + nvme_free_tree(r); + + return 0; +} diff --git a/test/meson.build b/test/meson.build new file mode 100644 index 0000000..193d558 --- /dev/null +++ b/test/meson.build @@ -0,0 +1,39 @@ +# SPDX-License-Identifier: LGPL-2.1-or-later +# +# This file is part of libnvme. +# Copyright (c) 2021 Dell Inc. +# +# Authors: Martin Belanger <Martin.Belanger@dell.com> + +# These tests all require interaction with a real NVMe device, so we don't +# define as meson unit-tests, and therefore get run as part of the 'test' +# target. However, they're available for developer use, when hardware is +# available. +main = executable( + 'main-test', + ['test.c'], + dependencies: libuuid_dep, + link_with: libnvme, + include_directories: [incdir, internal_incdir] +) + +cpp = executable( + 'test-cpp', + ['cpp.cc'], + link_with: libnvme, + include_directories: [incdir, internal_incdir] +) + +register = executable( + 'test-register', + ['register.c'], + link_with: libnvme, + include_directories: [incdir, internal_incdir] +) + +zns = executable( + 'test-zns', + ['zns.c'], + link_with: libnvme, + include_directories: [incdir, internal_incdir] +) diff --git a/test/register.c b/test/register.c new file mode 100644 index 0000000..8791083 --- /dev/null +++ b/test/register.c @@ -0,0 +1,231 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/** + * This file is part of libnvme. + * Copyright (c) 2020 Western Digital Corporation or its affiliates. + * + * Authors: Keith Busch <keith.busch@wdc.com> + */ + +/** + * Prints the values of the nvme register map. Use the nvme controller resource + * for your pci device found in /sys/class/nvme/nvmeX/device/resource0 + */ + +#include <fcntl.h> +#include <inttypes.h> +#include <libnvme.h> +#include <stdio.h> +#include <stdlib.h> +#include <stdint.h> +#include <unistd.h> + +#include <sys/mman.h> + +#include <ccan/endian/endian.h> + +static inline uint32_t nvme_mmio_read32(volatile void *addr) +{ + uint32_t *p = (__le32 *)addr; + + return le32_to_cpu(*p); +} + +static inline uint64_t nvme_mmio_read64(volatile void *addr) +{ + volatile __u32 *p = (__u32 *)addr; + uint32_t low, high; + + low = nvme_mmio_read32(p); + high = nvme_mmio_read32(p + 1); + + return low + ((uint64_t)high << 32); +} + +void nvme_print_registers(void *regs) +{ + __u64 cap = nvme_mmio_read64(regs + NVME_REG_CAP); + __u32 vs = nvme_mmio_read32(regs + NVME_REG_VS); + __u32 intms = nvme_mmio_read32(regs + NVME_REG_INTMS); + __u32 intmc = nvme_mmio_read32(regs + NVME_REG_INTMC); + __u32 cc = nvme_mmio_read32(regs + NVME_REG_CC); + __u32 csts = nvme_mmio_read32(regs + NVME_REG_CSTS); + __u32 nssr = nvme_mmio_read32(regs + NVME_REG_NSSR); + __u32 aqa = nvme_mmio_read32(regs + NVME_REG_AQA); + __u64 asq = nvme_mmio_read64(regs + NVME_REG_ASQ); + __u64 acq = nvme_mmio_read64(regs + NVME_REG_ACQ); + __u32 cmbloc = nvme_mmio_read32(regs + NVME_REG_CMBLOC); + __u32 cmbsz = nvme_mmio_read32(regs + NVME_REG_CMBSZ); + __u32 bpinfo = nvme_mmio_read32(regs + NVME_REG_BPINFO); + __u32 bprsel = nvme_mmio_read32(regs + NVME_REG_BPRSEL); + __u64 bpmbl = nvme_mmio_read64(regs + NVME_REG_BPMBL); + __u64 cmbmsc = nvme_mmio_read64(regs + NVME_REG_CMBMSC); + __u32 cmbsts = nvme_mmio_read32(regs + NVME_REG_CMBSTS); + __u32 pmrcap = nvme_mmio_read32(regs + NVME_REG_PMRCAP); + __u32 pmrctl = nvme_mmio_read32(regs + NVME_REG_PMRCTL); + __u32 pmrsts = nvme_mmio_read32(regs + NVME_REG_PMRSTS); + __u32 pmrebs = nvme_mmio_read32(regs + NVME_REG_PMREBS); + __u32 pmrswtp = nvme_mmio_read32(regs + NVME_REG_PMRSWTP); + __u64 pmrmsc = nvme_mmio_read32(regs + NVME_REG_PMRMSCL) | + (__u64)nvme_mmio_read64(regs + NVME_REG_PMRMSCU) << 32; + + printf("%-10s : %llx\n", "CAP", cap); + printf(" %-8s : %llx\n", "MQES", NVME_CAP_MQES(cap)); + printf(" %-8s : %llx\n", "CQRS", NVME_CAP_CQR(cap)); + printf(" %-8s : %llx\n", "AMS", NVME_CAP_AMS(cap)); + printf(" %-8s : %llx\n", "TO", NVME_CAP_TO(cap)); + printf(" %-8s : %llx\n", "DSTRD", NVME_CAP_DSTRD(cap)); + printf(" %-8s : %llx\n", "NSSRC", NVME_CAP_NSSRC(cap)); + printf(" %-8s : %llx\n", "CSS", NVME_CAP_CSS(cap)); + printf(" %-8s : %llx\n", "BPS", NVME_CAP_BPS(cap)); + printf(" %-8s : %llx\n", "MPSMIN", NVME_CAP_MPSMIN(cap)); + printf(" %-8s : %llx\n", "MPSMAX", NVME_CAP_MPSMAX(cap)); + printf(" %-8s : %llx\n", "CMBS", NVME_CAP_CMBS(cap)); + printf(" %-8s : %llx\n", "PMRS", NVME_CAP_PMRS(cap)); + + printf("%-10s : %x\n", "VS", vs); + printf(" %-8s : %x\n", "MJR", NVME_VS_TER(vs)); + printf(" %-8s : %x\n", "MNR", NVME_VS_MNR(vs)); + printf(" %-8s : %x\n", "TER", NVME_VS_MJR(vs)); + + printf("%-10s : %x\n", "INTMS", intms); + printf("%-10s : %x\n", "INTMC", intmc); + + printf("%-10s : %x\n", "CC", cc); + printf(" %-8s : %x\n", "EN", NVME_CC_EN(cc)); + printf(" %-8s : %x\n", "CSS", NVME_CC_CSS(cc)); + printf(" %-8s : %x\n", "MPS", NVME_CC_MPS(cc)); + printf(" %-8s : %x\n", "AMS", NVME_CC_AMS(cc)); + printf(" %-8s : %x\n", "SHN", NVME_CC_SHN(cc)); + printf(" %-8s : %x\n", "IOSQES", NVME_CC_IOSQES(cc)); + printf(" %-8s : %x\n", "IOCQES", NVME_CC_IOCQES(cc)); + + printf("%-10s : %x\n", "CSTS", csts); + printf(" %-8s : %x\n", "RDY", NVME_CSTS_RDY(csts)); + printf(" %-8s : %x\n", "CFS", NVME_CSTS_CFS(csts)); + printf(" %-8s : %x\n", "SHST", NVME_CSTS_SHST(csts)); + printf(" %-8s : %x\n", "NSSRO", NVME_CSTS_NSSRO(csts)); + printf(" %-8s : %x\n", "PP", NVME_CSTS_PP(csts)); + + printf("%-10s : %x\n", "NSSR", nssr); + + printf("%-10s : %x\n", "AQA", aqa); + printf(" %-8s : %x\n", "ASQS", NVME_AQA_ASQS(aqa)); + printf(" %-8s : %x\n", "ACQS", NVME_AQA_ACQS(aqa)); + + printf("%-10s : %llx\n", "ASQ", asq); + printf("%-10s : %llx\n", "ACQ", acq); + + printf("%-10s : %x\n", "CMBLOC", cmbloc); + printf(" %-8s : %x\n", "BIR", NVME_CMBLOC_BIR(cmbloc)); + printf(" %-8s : %x\n", "CQMMS", NVME_CMBLOC_CQMMS(cmbloc)); + printf(" %-8s : %x\n", "CQPDS", NVME_CMBLOC_CQPDS(cmbloc)); + printf(" %-8s : %x\n", "CDPLMS", NVME_CMBLOC_CDPLMS(cmbloc)); + printf(" %-8s : %x\n", "CDPCILS", NVME_CMBLOC_CDPCILS(cmbloc)); + printf(" %-8s : %x\n", "CDMMMS", NVME_CMBLOC_CDMMMS(cmbloc)); + printf(" %-8s : %x\n", "CQDA", NVME_CMBLOC_CQDA(cmbloc)); + printf(" %-8s : %x\n", "OFST", NVME_CMBLOC_OFST(cmbloc)); + + printf("%-10s : %x\n", "CMBSZ", cmbsz); + printf(" %-8s : %x\n", "SQS", NVME_CMBSZ_SQS(cmbsz)); + printf(" %-8s : %x\n", "CQS", NVME_CMBSZ_CQS(cmbsz)); + printf(" %-8s : %x\n", "LISTS", NVME_CMBSZ_LISTS(cmbsz)); + printf(" %-8s : %x\n", "RDS", NVME_CMBSZ_RDS(cmbsz)); + printf(" %-8s : %x\n", "WDS", NVME_CMBSZ_WDS(cmbsz)); + printf(" %-8s : %x\n", "SZU", NVME_CMBSZ_SZU(cmbsz)); + printf(" %-8s : %x\n", "SZ", NVME_CMBSZ_SZ(cmbsz)); + printf(" %-8s : %llx\n", "bytes", nvme_cmb_size(cmbsz)); + + printf("%-10s : %x\n", "BPINFO", bpinfo); + printf(" %-8s : %x\n", "BPSZ", NVME_BPINFO_BPSZ(bpinfo)); + printf(" %-8s : %x\n", "BRS", NVME_BPINFO_BRS(bpinfo)); + printf(" %-8s : %x\n", "ABPID", NVME_BPINFO_ABPID(bpinfo)); + + printf("%-10s : %x\n", "BPRSEL", bprsel); + printf(" %-8s : %x\n", "BPRSZ", NVME_BPRSEL_BPRSZ(bprsel)); + printf(" %-8s : %x\n", "BPROF", NVME_BPRSEL_BPROF(bprsel)); + printf(" %-8s : %x\n", "BPID", NVME_BPRSEL_BPID(bprsel)); + + printf("%-10s : %llx\n", "BPMBL", bpmbl); + + printf("%-10s : %llx\n", "CMBMSC", cmbmsc); + printf(" %-8s : %llx\n", "CRE", NVME_CMBMSC_CRE(cmbmsc)); + printf(" %-8s : %llx\n", "CMSE", NVME_CMBMSC_CMSE(cmbmsc)); + printf(" %-8s : %llx\n", "CBA", NVME_CMBMSC_CBA(cmbmsc)); + + printf("%-10s : %x\n", "CMBSTS", cmbsts); + printf(" %-8s : %x\n", "CBAI", NVME_CMBSTS_CBAI(cmbsts)); + + printf("%-10s : %x\n", "PMRCAP", pmrcap); + printf(" %-8s : %x\n", "RDS", NVME_PMRCAP_RDS(pmrcap)); + printf(" %-8s : %x\n", "WDS", NVME_PMRCAP_WDS(pmrcap)); + printf(" %-8s : %x\n", "BIR", NVME_PMRCAP_BIR(pmrcap)); + printf(" %-8s : %x\n", "PMRTU", NVME_PMRCAP_PMRTU(pmrcap)); + printf(" %-8s : %x\n", "PMRWMB", NVME_PMRCAP_PMRWMB(pmrcap)); + printf(" %-8s : %x\n", "PMRTO", NVME_PMRCAP_PMRTO(pmrcap)); + printf(" %-8s : %x\n", "CMSS", NVME_PMRCAP_CMSS(pmrcap)); + + printf("%-10s : %x\n", "PMRCTL", pmrctl); + printf(" %-8s : %x\n", "EN", NVME_PMRCTL_EN(pmrctl)); + + printf("%-10s : %x\n", "PMRSTS", pmrsts); + printf(" %-8s : %x\n", "ERR", NVME_PMRSTS_ERR(pmrsts)); + printf(" %-8s : %x\n", "NRDY", NVME_PMRSTS_NRDY(pmrsts)); + printf(" %-8s : %x\n", "HSTS", NVME_PMRSTS_HSTS(pmrsts)); + printf(" %-8s : %x\n", "CBAI", NVME_PMRSTS_CBAI(pmrsts)); + + printf("%-10s : %x\n", "PMREBS", pmrebs); + printf(" %-8s : %x\n", "PMRSZU", NVME_PMREBS_PMRSZU(pmrebs)); + printf(" %-8s : %x\n", "RBB", NVME_PMREBS_RBB(pmrebs)); + printf(" %-8s : %x\n", "PMRWBZ", NVME_PMREBS_PMRWBZ(pmrebs)); + printf(" %-8s : %llx\n", "bytes", nvme_pmr_size(pmrebs)); + + printf("%-10s : %x\n", "PMRSWTP", pmrswtp); + printf(" %-8s : %x\n", "PMRSWTU", NVME_PMRSWTP_PMRSWTU(pmrswtp)); + printf(" %-8s : %x\n", "PMRSWTV", NVME_PMRSWTP_PMRSWTV(pmrswtp)); + printf(" %-8s : %llx\n", "tput", nvme_pmr_throughput(pmrswtp)); + + printf("%-10s : %llx\n", "PMRMSC", pmrmsc); + printf(" %-8s : %llx\n", "CMSE", NVME_PMRMSC_CMSE(pmrmsc)); + printf(" %-8s : %llx\n", "CBA", NVME_PMRMSC_CBA(pmrmsc)); +} + +int main(int argc, char **argv) +{ + int ret, fd; + char *path; + void *regs; + + if (argc != 2) { + fprintf(stderr, "%s nvme<X>\n", argv[0]); + return 1; + } + + ret = asprintf(&path, "/sys/class/nvme/%s/device/resource0", argv[1]); + if (ret < 0) + return 0; + + printf("open %s\n", path); + fd = open(path, O_RDONLY | O_SYNC); + if (fd < 0) { + fprintf(stderr, "failed to open %s\n", path); + free(path); + return 1; + } + + regs = mmap(NULL, getpagesize(), PROT_READ, MAP_SHARED, fd, 0); + if (regs == MAP_FAILED) { + fprintf(stderr, "failed to map device BAR\n"); + fprintf(stderr, "did your kernel enable CONFIG_IO_STRICT_DEVMEM?\n"); + free(path); + close(fd); + return 1; + } + + nvme_print_registers(regs); + munmap(regs, getpagesize()); + free(path); + close(fd); + + return 0; +} + diff --git a/test/test.c b/test/test.c new file mode 100644 index 0000000..bf13412 --- /dev/null +++ b/test/test.c @@ -0,0 +1,432 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/** + * This file is part of libnvme. + * Copyright (c) 2020 Western Digital Corporation or its affiliates. + * + * Authors: Keith Busch <keith.busch@wdc.com> + */ + +/** + * Basic libnvme test: uses scan filters, single controllers, and many admin + * command APIs for identifications, logs, and features. No verification for + * specific values are performed: the test will only report which commands + * executed were completed successfully or with an error. User inspection of + * the output woould be required to know if everything is working when the + * program exists successfully; an ungraceful exit means a bug exists + * somewhere. + */ +#include <stdio.h> +#include <string.h> +#include <stdbool.h> +#include <inttypes.h> +#include <uuid/uuid.h> +#include <libnvme.h> + +#include <ccan/endian/endian.h> + +static bool nvme_match_subsysnqn_filter(nvme_subsystem_t s, + nvme_ctrl_t c, nvme_ns_t ns, void *f_args) +{ + char *nqn_match = f_args; + + if (s) + return strcmp(nvme_subsystem_get_nqn(s), nqn_match) == 0; + return true; +} + +static int test_ctrl(nvme_ctrl_t c) +{ + static __u8 buf[0x1000]; + + enum nvme_get_features_sel sel = NVME_GET_FEATURES_SEL_CURRENT; + int ret, temp, fd = nvme_ctrl_get_fd(c); + struct nvme_error_log_page error[64]; + struct nvme_smart_log smart = { 0 }; + struct nvme_firmware_slot fw = { 0 }; + struct nvme_ns_list ns_list = { 0 }; + struct nvme_cmd_effects_log cfx = { 0 }; + struct nvme_self_test_log st = { 0 }; + struct nvme_telemetry_log *telem = (void *)buf; + struct nvme_endurance_group_log eglog = { 0 }; + struct nvme_ana_group_desc *analog = (void *)buf; + struct nvme_resv_notification_log resvnotify = { 0 }; + struct nvme_sanitize_log_page sanlog = { 0 }; + struct nvme_id_uuid_list uuid = { 0 }; + struct nvme_id_ns_granularity_list gran = { 0 }; + struct nvme_secondary_ctrl_list sec = { 0 }; + struct nvme_primary_ctrl_cap prim = { 0 }; + struct nvme_ctrl_list ctrlist = { 0 }; + struct nvme_id_ctrl id = { 0 }; + + __u32 result; + + ret = nvme_ctrl_identify(c, &id); + if (ret) { + printf("ERROR: no identify for:%s\n", nvme_ctrl_get_name(c)); + return ret; + } + else { + printf("PASSED: Identify controller\n"); + } + + ret = nvme_get_log_smart(fd, NVME_NSID_ALL, true, &smart); + if (ret) { + printf("ERROR: no smart log for:%s %#x\n", nvme_ctrl_get_name(c), ret); + return ret; + } + else { + printf("PASSED: smart log\n"); + } + + temp = ((smart.temperature[1] << 8) | smart.temperature[0]) - 273; + printf("Controller:%s\n", nvme_ctrl_get_name(c)); + printf("\nIdentify:\n"); + printf(" vid:%#04x\n", le16_to_cpu(id.vid)); + printf(" ssvid:%#04x\n", le16_to_cpu(id.ssvid)); + printf(" oacs:%#x\n", id.oacs); + printf(" lpa:%#x\n", id.lpa); + printf(" sn:%-.20s\n", id.sn); + printf(" model:%-.40s\n", id.mn); + + ret = nvme_identify_allocated_ns_list(fd, 0, &ns_list); + if (!ret) + printf(" PASSED: Allocated NS List\n"); + else + printf(" ERROR: Allocated NS List:%x\n", ret); + ret = nvme_identify_active_ns_list(fd, 0, &ns_list); + if (!ret) + printf(" PASSED: Active NS List\n"); + else + printf(" ERROR: Active NS List:%x\n", ret); + ret = nvme_identify_ctrl_list(fd, 0, &ctrlist); + if (!ret) + printf(" PASSED: Ctrl List\n"); + else + printf(" ERROR: CtrlList:%x\n", ret); + ret = nvme_identify_nsid_ctrl_list(fd, 1, 0, &ctrlist); + if (!ret) + printf(" PASSED: NSID Ctrl List\n"); + else + printf(" ERROR: NSID CtrlList:%x\n", ret); + ret = nvme_identify_primary_ctrl(fd, 0, &prim); + if (!ret) + printf(" PASSED: Identify Primary\n"); + else + printf(" ERROR: Identify Primary:%x\n", ret); + ret = nvme_identify_secondary_ctrl_list(fd, 1, 0, &sec); + if (!ret) + printf(" PASSED: Identify Secondary\n"); + else + printf(" ERROR: Identify Secondary:%x\n", ret); + ret = nvme_identify_ns_granularity(fd, &gran); + if (!ret) + printf(" PASSED: Identify NS granularity\n"); + else + printf(" ERROR: Identify NS granularity:%x\n", ret); + ret = nvme_identify_uuid(fd, &uuid); + if (!ret) + printf(" PASSED: Identify UUID List\n"); + else + printf(" ERROR: Identify UUID List:%x\n", ret); + + printf("\nLogs\n"); + printf(" SMART: Current temperature:%d percent used:%d%%\n", temp, + smart.percent_used); + ret = nvme_get_log_sanitize(fd, true, &sanlog); + if (!ret) + printf(" Sanitize Log:\n"); + else + printf(" ERROR: Sanitize Log:%x\n", ret); + ret = nvme_get_log_reservation(fd, true, &resvnotify); + if (!ret) + printf(" Reservation Log\n"); + else + printf(" ERROR: Reservation Log:%x\n", ret); + ret = nvme_get_log_ana_groups(fd, true, sizeof(buf), analog); + if (!ret) + printf(" ANA Groups\n"); + else + printf(" ERROR: ANA Groups:%x\n", ret); + ret = nvme_get_log_endurance_group(fd, 0, &eglog); + if (!ret) + printf(" Endurance Group\n"); + else + printf(" ERROR: Endurance Group:%x\n", ret); + ret = nvme_get_log_telemetry_ctrl(fd, true, 0, sizeof(buf), telem); + if (!ret) + printf(" Telemetry Controller\n"); + else + printf(" ERROR: Telemetry Controller:%x\n", ret); + ret = nvme_get_log_device_self_test(fd, &st); + if (!ret) + printf(" Device Self Test\n"); + else + printf(" ERROR: Device Self Test:%x\n", ret); + ret = nvme_get_log_cmd_effects(fd, NVME_CSI_NVM, &cfx); + if (!ret) + printf(" Command Effects\n"); + else + printf(" ERROR: Command Effects:%x\n", ret); + ret = nvme_get_log_changed_ns_list(fd, true, &ns_list); + if (!ret) + printf(" Change NS List\n"); + else + printf(" ERROR: Change NS List:%x\n", ret); + ret = nvme_get_log_fw_slot(fd, true, &fw); + if (!ret) + printf(" FW Slot\n"); + else + printf(" ERROR: FW Slot%x\n", ret); + ret = nvme_get_log_error(fd, 64, true, error); + if (!ret) + printf(" Error Log\n"); + else + printf(" ERROR: Error Log:%x\n", ret); + printf("\nFeatures\n"); + ret = nvme_get_features_arbitration(fd, sel, &result); + if (!ret) + printf(" Arbitration:%x\n", result); + else if (ret > 0) + printf(" ERROR: Arbitration:%x\n", ret); + ret = nvme_get_features_power_mgmt(fd, sel, &result); + if (!ret) + printf(" Power Management:%x\n", result); + else if (ret > 0) + printf(" ERROR: Power Management:%x\n", ret); + ret = nvme_get_features_temp_thresh(fd, sel, &result); + if (!ret) + printf(" Temperature Threshold:%x\n", result); + else if (ret > 0) + printf(" ERROR: Temperature Threshold:%x\n", ret); + ret = nvme_get_features_err_recovery(fd, sel, &result); + if (!ret) + printf(" Error Recovery:%x\n", result); + else if (ret > 0) + printf(" ERROR: Error Recovery:%x\n", ret); + ret = nvme_get_features_volatile_wc(fd, sel, &result); + if (!ret) + printf(" Volatile Write Cache:%x\n", result); + else if (ret > 0) + printf(" ERROR: Volatile Write Cache:%x\n", ret); + ret = nvme_get_features_num_queues(fd, sel, &result); + if (!ret) + printf(" Number of Queues:%x\n", result); + else if (ret > 0) + printf(" ERROR: Number of Queues:%x\n", ret); + ret = nvme_get_features_irq_coalesce(fd, sel, &result); + if (!ret) + printf(" IRQ Coalescing:%x\n", result); + else if (ret > 0) + printf(" ERROR: IRQ Coalescing:%x\n", ret); + ret = nvme_get_features_write_atomic(fd, sel, &result); + if (!ret) + printf(" Write Atomic:%x\n", result); + else if (ret > 0) + printf(" ERROR: Write Atomic:%x\n", ret); + ret = nvme_get_features_async_event(fd, sel, &result); + if (!ret) + printf(" Asycn Event Config:%x\n", result); + else if (ret > 0) + printf(" ERROR: Asycn Event Config:%x\n", ret); + ret = nvme_get_features_hctm(fd, sel, &result); + if (!ret) + printf(" HCTM:%x\n", result); + else if (ret > 0) + printf(" ERROR: HCTM:%x\n", ret); + ret = nvme_get_features_nopsc(fd, sel, &result); + if (!ret) + printf(" NOP Power State Config:%x\n", result); + else if (ret > 0) + printf(" ERROR: NOP Power State Configrbitration:%x\n", ret); + ret = nvme_get_features_rrl(fd, sel, &result); + if (!ret) + printf(" Read Recover Levels:%x\n", result); + else if (ret > 0) + printf(" ERROR: Read Recover Levels:%x\n", ret); + ret = nvme_get_features_lba_sts_interval(fd, sel, &result); + if (!ret) + printf(" LBA Status Interval:%x\n", result); + else if (ret > 0) + printf(" ERROR: LBA Status Interval:%x\n", ret); + ret = nvme_get_features_sanitize(fd, sel, &result); + if (!ret) + printf(" Sanitize:%x\n", result); + else if (ret > 0) + printf(" ERROR: SW Progress Marker:%x\n", ret); + ret = nvme_get_features_sw_progress(fd, sel, &result); + if (!ret) + printf(" SW Progress Marker:%x\n", result); + else if (ret > 0) + printf(" ERROR: Sanitize:%x\n", ret); + ret = nvme_get_features_resv_mask(fd, sel, &result); + if (!ret) + printf(" Reservation Mask:%x\n", result); + else if (ret > 0) + printf(" ERROR: Reservation Mask:%x\n", ret); + ret = nvme_get_features_resv_persist(fd, sel, &result); + if (!ret) + printf(" Reservation Persistence:%x\n", result); + else if (ret > 0) + printf(" ERROR: Reservation Persistence:%x\n", ret); + return 0; +} + +static int test_namespace(nvme_ns_t n) +{ + int ret, nsid = nvme_ns_get_nsid(n), fd = nvme_ns_get_fd(n); + struct nvme_id_ns ns = { 0 }, allocated = { 0 }; + struct nvme_ns_id_desc descs = { 0 }; + __u32 result = 0; + __u8 flbas; + + ret = nvme_ns_identify(n, &ns); + if (ret) + return ret; + + nvme_id_ns_flbas_to_lbaf_inuse(ns.flbas, &flbas); + printf("%s: nsze:%" PRIu64 " lba size:%d\n", + nvme_ns_get_name(n), le64_to_cpu(ns.nsze), + 1 << ns.lbaf[flbas].ds); + + ret = nvme_identify_allocated_ns(fd, nsid, &allocated); + if (!ret) + printf(" Identify allocated ns\n"); + else + printf(" ERROR: Identify allocated ns:%x\n", ret); + ret = nvme_identify_ns_descs(fd, nsid, &descs); + if (!ret) + printf(" Identify NS Descriptors\n"); + else + printf(" ERROR: Identify NS Descriptors:%x\n", ret); + ret = nvme_get_features_write_protect(fd, nsid, + NVME_GET_FEATURES_SEL_CURRENT, &result); + if (!ret) + printf(" Write Protect:%x\n", result); + else if (ret > 0) + printf(" ERROR: Write Protect:%x\n", ret); + return 0; +} + +static void print_hex(const uint8_t *x, int len) +{ + int i; + + for (i = 0; i < len; i++) + printf("%02x", x[i]); +} + +int main(int argc, char **argv) +{ + nvme_root_t r; + nvme_host_t h; + nvme_subsystem_t s; + nvme_ctrl_t c; + nvme_path_t p; + nvme_ns_t n; + const char *ctrl = "nvme4"; + const char *nqn_match = "testnqn"; + + printf("Test filter for common loop back target\n"); + r = nvme_create_root(NULL, DEFAULT_LOGLEVEL); + if (!r) + return 1; + nvme_scan_topology(r, nvme_match_subsysnqn_filter, (void *)nqn_match); + nvme_for_each_host(r, h) { + nvme_for_each_subsystem(h, s) { + printf("%s - NQN=%s\n", nvme_subsystem_get_name(s), + nvme_subsystem_get_nqn(s)); + nvme_subsystem_for_each_ctrl(s, c) { + printf(" %s %s %s %s\n", nvme_ctrl_get_name(c), + nvme_ctrl_get_transport(c), + nvme_ctrl_get_address(c), + nvme_ctrl_get_state(c)); + } + } + } + printf("\n"); + + if (argc > 1) + ctrl = argv[1]; + + printf("Test scan specific controller\n"); + c = nvme_scan_ctrl(r, ctrl); + if (c) { + printf("%s %s %s %s\n", nvme_ctrl_get_name(c), + nvme_ctrl_get_transport(c), + nvme_ctrl_get_address(c), + nvme_ctrl_get_state(c)); + nvme_free_ctrl(c); + } + printf("\n"); + nvme_free_tree(r); + + r = nvme_scan(NULL); + if (!r) + return -1; + + printf("Test walking the topology\n"); + nvme_for_each_host(r, h) { + nvme_for_each_subsystem(h, s) { + printf("%s - NQN=%s\n", nvme_subsystem_get_name(s), + nvme_subsystem_get_nqn(s)); + nvme_subsystem_for_each_ctrl(s, c) { + printf(" `- %s %s %s %s\n", + nvme_ctrl_get_name(c), + nvme_ctrl_get_transport(c), + nvme_ctrl_get_address(c), + nvme_ctrl_get_state(c)); + + nvme_ctrl_for_each_ns(c, n) { + char uuid_str[40]; + uuid_t uuid; + printf(" `- %s lba size:%d lba max:%" PRIu64 "\n", + nvme_ns_get_name(n), + nvme_ns_get_lba_size(n), + nvme_ns_get_lba_count(n)); + printf(" eui:"); + print_hex(nvme_ns_get_eui64(n), 8); + printf(" nguid:"); + print_hex(nvme_ns_get_nguid(n), 16); + nvme_ns_get_uuid(n, uuid); + uuid_unparse_lower(uuid, uuid_str); + printf(" uuid:%s csi:%d\n", uuid_str, + nvme_ns_get_csi(n)); + } + + nvme_ctrl_for_each_path(c, p) + printf(" `- %s %s\n", + nvme_path_get_name(p), + nvme_path_get_ana_state(p)); + } + + nvme_subsystem_for_each_ns(s, n) { + printf(" `- %s lba size:%d lba max:%" PRIu64 "\n", + nvme_ns_get_name(n), + nvme_ns_get_lba_size(n), + nvme_ns_get_lba_count(n)); + } + } + printf("\n"); + } + + printf("Test identification, logs, and features\n"); + nvme_for_each_host(r, h) { + nvme_for_each_subsystem(h, s) { + nvme_subsystem_for_each_ctrl(s, c) { + test_ctrl(c); + printf("\n"); + nvme_ctrl_for_each_ns(c, n) { + test_namespace(n); + printf("\n"); + } + } + nvme_subsystem_for_each_ns(s, n) { + test_namespace(n); + printf("\n"); + } + } + } + nvme_free_tree(r); + + return 0; +} diff --git a/test/tree.py b/test/tree.py new file mode 100644 index 0000000..626a0aa --- /dev/null +++ b/test/tree.py @@ -0,0 +1,23 @@ +#!/usr/bin/python3 +''' +SPDX-License-Identifier: LGPL-3.1-or-later + +This file is part of libnvme. +Copyright (c) 2021 SUSE Software Solutions AG + +Authors: Hannes Reinecke <hare@suse.de> + +Scans the NVMe subsystem and prints out all found hosts, +subsystems, and controllers +''' + +import libnvme + +r = libnvme.nvme_root() +for h in r.hosts(): + print (h) + for s in h.subsystems(): + print (s) + for c in s.controllers(): + print (c) + diff --git a/test/zns.c b/test/zns.c new file mode 100644 index 0000000..b654986 --- /dev/null +++ b/test/zns.c @@ -0,0 +1,88 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/** + * This file is part of libnvme. + * Copyright (c) 2020 Western Digital Corporation or its affiliates. + * + * Authors: Keith Busch <keith.busch@wdc.com> + */ + +/** + * Search out for ZNS type namespaces, and if found, report their properties. + */ +#include <stdio.h> +#include <string.h> +#include <stdbool.h> +#include <stdlib.h> +#include <libnvme.h> +#include <inttypes.h> + +#include <ccan/endian/endian.h> + +static void show_zns_properties(nvme_ns_t n) +{ + struct nvme_zns_id_ns zns_ns; + struct nvme_zns_id_ctrl zns_ctrl; + struct nvme_zone_report *zr; + __u32 result; + + zr = calloc(1, 0x1000); + if (!zr) + return; + + if (nvme_zns_identify_ns(nvme_ns_get_fd(n), nvme_ns_get_nsid(n), + &zns_ns)) { + fprintf(stderr, "failed to identify zns ns\n");; + } + + printf("zoc:%x ozcs:%x mar:%x mor:%x\n", le16_to_cpu(zns_ns.zoc), + le16_to_cpu(zns_ns.ozcs), le32_to_cpu(zns_ns.mar), + le32_to_cpu(zns_ns.mor)); + + if (nvme_zns_identify_ctrl(nvme_ns_get_fd(n), &zns_ctrl)) { + fprintf(stderr, "failed to identify zns ctrl\n");; + return; + } + + printf("zasl:%u\n", zns_ctrl.zasl); + + if (nvme_zns_report_zones(nvme_ns_get_fd(n), nvme_ns_get_nsid(n), 0, + NVME_ZNS_ZRAS_REPORT_ALL, false, + true, 0x1000, (void *)zr, + NVME_DEFAULT_IOCTL_TIMEOUT, &result)) { + fprintf(stderr, "failed to report zones, result %x\n", + le32_to_cpu(result)); + return; + } + + printf("nr_zones:%"PRIu64"\n", le64_to_cpu(zr->nr_zones)); + free(zr); +} + +int main() +{ + nvme_subsystem_t s; + nvme_root_t r; + nvme_host_t h; + nvme_ctrl_t c; + nvme_ns_t n; + + r = nvme_scan(NULL); + if (!r) + return -1; + + nvme_for_each_host(r, h) { + nvme_for_each_subsystem(h, s) { + nvme_subsystem_for_each_ctrl(s, c) { + nvme_ctrl_for_each_ns(c, n) { + if (nvme_ns_get_csi(n) == NVME_CSI_ZNS) + show_zns_properties(n); + } + } + nvme_subsystem_for_each_ns(s, n) { + if (nvme_ns_get_csi(n) == NVME_CSI_ZNS) + show_zns_properties(n); + } + } + } + nvme_free_tree(r); +} |