pax_global_header00006660000000000000000000000064141775117240014523gustar00rootroot0000000000000052 comment=4040c23c0841b9b1fbf9397f842a9e9cec7356b5 thinkfan-1.3.1/000077500000000000000000000000001417751172400133275ustar00rootroot00000000000000thinkfan-1.3.1/.github/000077500000000000000000000000001417751172400146675ustar00rootroot00000000000000thinkfan-1.3.1/.github/workflows/000077500000000000000000000000001417751172400167245ustar00rootroot00000000000000thinkfan-1.3.1/.github/workflows/ccpp.yml000066400000000000000000000010261417751172400203730ustar00rootroot00000000000000name: C/C++ CI on: push: branches: [ master ] pull_request: branches: [ master ] jobs: build-ubuntu: runs-on: ${{ matrix.os }} strategy: matrix: os: [ubuntu-18.04, ubuntu-20.04] steps: - uses: actions/checkout@v2 - name: install-deps run: sudo apt install libyaml-cpp-dev libatasmart-dev cmake - name: build run: | mkdir build cmake -B build cmake --build build - name: install run: sudo cmake --install ${{ github.workspace }}/build thinkfan-1.3.1/CMakeLists.txt000066400000000000000000000127031417751172400160720ustar00rootroot00000000000000project(thinkfan) include(GNUInstallDirs) set(THINKFAN_VERSION 1.3.1) cmake_minimum_required(VERSION 3.0) # Generate absolute paths or something cmake_policy(SET CMP0015 NEW) find_package(PkgConfig) find_package(Threads) pkg_check_modules(SYSTEMD "systemd") pkg_check_modules(OPENRC "openrc") pkg_check_modules(YAML_CPP "yaml-cpp") if(YAML_CPP_FOUND AND YAML_CPP_VERSION VERSION_LESS "0.5.3") message(WARNING "yaml-cpp version ${YAML_CPP_VERSION} is very old, buggy and lacks some features. Thinkfan will not always be able to point out the location of errors in the YAML config.") add_definitions(-DHAVE_OLD_YAMLCPP) endif() pkg_check_modules(ATASMART "libatasmart") if(SYSTEMD_FOUND) set(PID_FILE "/run/thinkfan.pid") else() set(PID_FILE "/var/run/thinkfan.pid") endif() # # Defaults to OFF because libatasmart seems to be horribly inefficient # option(USE_ATASMART "Enable reading temperatures from HDDs via S.M.A.R.T" OFF) # # Defaults to ON because it seems reasonably fast. The libnvidia-ml.so is # loaded at runtime, so we don't add a compile-time dependency on the # proprietary nVidia driver. # option(USE_NVML "Get temperatures directly from nVidia GPUs via their proprietary NVML API" ON) # # The shiny new YAML config parser. Depends on yaml-cpp. # option(USE_YAML "Enable the new YAML-based config format" ON) option(DISABLE_BUGGER "Disable bug detection, i.e. dont't catch segfaults and unhandled exceptions" OFF) option(DISABLE_SYSLOG "Disable logging to syslog, always log to stdout" OFF) option(DISABLE_EXCEPTION_CATCHING "Terminate with SIGABRT on all exceptions, causing a core dump on every error" OFF) set(SRC_FILES src/thinkfan.cpp src/config.cpp src/fans.cpp src/sensors.cpp src/message.cpp src/parser.cpp src/error.cpp) if(USE_YAML) if(NOT YAML_CPP_FOUND) message(FATAL_ERROR "USE_YAML enabled but yaml-cpp not found. Please install yaml-cpp[-devel]!") endif() set(SRC_FILES ${SRC_FILES} src/yamlconfig.cpp) endif(USE_YAML) # # Set default build type # if(NOT CMAKE_BUILD_TYPE) set(CMAKE_BUILD_TYPE "RelWithDebInfo" CACHE STRING "Options are: Debug Release RelWithDebInfo MinSizeRel." FORCE) endif(NOT CMAKE_BUILD_TYPE) add_compile_options(-Wall -std=c++1y) set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g3 -DDEBUG") add_executable(thinkfan ${SRC_FILES}) if (PID_FILE) target_compile_definitions(thinkfan PRIVATE -DPID_FILE=\"${PID_FILE}\") endif() target_compile_definitions(thinkfan PRIVATE -DVERSION="${THINKFAN_VERSION}") # std::condition_variable::wait_for doesn't block if not explicitly linked against libpthread # https://stackoverflow.com/questions/41394670/c-condition-variable-wait-for-returns-instantly # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=58929 target_link_libraries(thinkfan PRIVATE ${CMAKE_THREAD_LIBS_INIT}) if(USE_ATASMART) if(NOT ATASMART_FOUND) message(FATAL_ERROR "USE_ATASMART enabled but libatasmart not found. Please install libatasmart[-devel]!") else() target_compile_definitions(thinkfan PRIVATE -DUSE_ATASMART) target_link_libraries(thinkfan PRIVATE atasmart) endif() endif(USE_ATASMART) if(USE_NVML) target_include_directories(thinkfan PRIVATE "include") target_compile_definitions(thinkfan PRIVATE -DUSE_NVML) target_link_libraries(thinkfan PRIVATE dl) endif(USE_NVML) if(USE_YAML) target_compile_definitions(thinkfan PRIVATE -DUSE_YAML) target_include_directories(thinkfan PRIVATE ${YAML_CPP_INCLUDE_DIRS}) target_link_libraries(thinkfan PRIVATE ${YAML_CPP_LIBRARIES}) endif(USE_YAML) if(SYSTEMD_FOUND) target_compile_definitions(thinkfan PRIVATE -DHAVE_SYSTEMD) endif() if(DISABLE_BUGGER) target_compile_definitions(thinkfan PRIVATE -DDISABLE_BUGGER) endif(DISABLE_BUGGER) if(DISABLE_SYSLOG) target_compile_definitions(thinkfan PRIVATE -DDISABLE_SYSLOG) endif(DISABLE_SYSLOG) if(DISABLE_EXCEPTION_CATCHING) target_compile_definitions(thinkfan PRIVATE -DDISABLE_EXCEPTION_CATCHING) endif(DISABLE_EXCEPTION_CATCHING) configure_file(src/thinkfan.1.cmake thinkfan.1) configure_file(src/thinkfan.conf.5.cmake thinkfan.conf.5) configure_file(src/thinkfan.conf.legacy.5.cmake thinkfan.conf.legacy.5) install(TARGETS thinkfan DESTINATION "${CMAKE_INSTALL_SBINDIR}") install(FILES COPYING README.md examples/thinkfan.yaml DESTINATION "${CMAKE_INSTALL_DOCDIR}") install(FILES ${CMAKE_BINARY_DIR}/thinkfan.1 DESTINATION "${CMAKE_INSTALL_MANDIR}/man1") install(FILES ${CMAKE_BINARY_DIR}/thinkfan.conf.5 DESTINATION "${CMAKE_INSTALL_MANDIR}/man5") install(FILES ${CMAKE_BINARY_DIR}/thinkfan.conf.legacy.5 DESTINATION "${CMAKE_INSTALL_MANDIR}/man5") if(SYSTEMD_FOUND) configure_file(rcscripts/systemd/thinkfan.service.cmake rcscripts/systemd/thinkfan.service) install(FILES rcscripts/systemd/thinkfan-sleep.service rcscripts/systemd/thinkfan-wakeup.service "${CMAKE_BINARY_DIR}/rcscripts/systemd/thinkfan.service" DESTINATION "${CMAKE_INSTALL_PREFIX}/lib/systemd/system") if(NOT EXISTS "/etc/systemd/system/thinkfan.service.d/override.conf") install(FILES rcscripts/systemd/override.conf DESTINATION "/etc/systemd/system/thinkfan.service.d") else() install(FILES rcscripts/systemd/override.conf DESTINATION "/etc/systemd/system/thinkfan.service.d" RENAME "default.conf") endif() endif(SYSTEMD_FOUND) if(OPENRC_FOUND) configure_file(rcscripts/openrc/thinkfan.cmake rcscripts/openrc/thinkfan) install(FILES "${CMAKE_BINARY_DIR}/rcscripts/openrc/thinkfan" PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE DESTINATION "/etc/init.d") endif(OPENRC_FOUND) thinkfan-1.3.1/COPYING000066400000000000000000001045131417751172400143660ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, 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 them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If 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 convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU 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 Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "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 PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM 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 PROGRAM (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 PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read . thinkfan-1.3.1/README.md000066400000000000000000000066521417751172400146170ustar00rootroot00000000000000# thinkfan [![Total alerts](https://img.shields.io/lgtm/alerts/g/vmatare/thinkfan.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/vmatare/thinkfan/alerts/)[![Language grade: C/C++](https://img.shields.io/lgtm/grade/cpp/g/vmatare/thinkfan.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/vmatare/thinkfan/context:cpp) Thinkfan is a simple, lightweight fan control program. # WARNING There's only very basic sanity checking on the configuration (semantic plausibility). You can set the temperature limits as insane as you like. Any change to fan behaviour that results in higher temperatures in some parts of the system will shorten your system's lifetime and/or cause weird hardware bugs that'll make you pull out your hair. **No warranties whatsoever** If this program steals your car, kills your horse, smokes your dope or pees on your carpet... too bad, you're on your own. # Building and installing To compile thinkfan, you will need to have the following things installed: - A recent C++ compiler (GCC >= 4.8 or clang) - pkgconfig or an equivalent (pkgconf or pkg-config) - cmake (and optionally a cmake GUI if you want to configure interactively) - optional: libyaml-cpp for YAML support (the -dev or -devel package) 1. In the thinkfan main directory, do ```bash mkdir build && cd build ``` 2. Then configure your build, either interactively: ```bash ccmake .. ``` Or set your build options from the command line. E.g. to configure a build with full debugging support: ```bash cmake -D CMAKE_BUILD_TYPE:STRING=Debug .. ``` `CMAKE_BUILD_TYPE:STRING` can also be `Release`, which produces a fully optimized binary, or `RelWithDebInfo`, which is also optimized but can still be debugged with gdb. Other options are: `USE_NVML:BOOL` (default: `ON`) Allows thinkfan to read GPU temperatures from the proprietary nVidia driver. The interface library is loaded dynamically, so it does not need to be installed when compiling. `USE_ATASMART:BOOL` (default: `OFF`) Enable libatasmart to read temperatures directly from hard disks. Use this only when you really need it, since libatasmart is unreasonably CPU-intensive. `USE_YAML:BOOL` (default: `ON`) Support config file in the new, more flexible YAML format. The old config format will be deprecated after the thinkfan 1.0 release. New features will be supported in YAML configs only. See examples/thinkfan.conf.yaml. Requires libyaml-cpp. 3. To compile simply run: ```bash make ``` 4. If you did not change `CMAKE_INSTALL_PREFIX`, thinkfan will be installed under `/usr/local` by doing: ```bash sudo make install ``` CMake will detect whether you use OpenRC or systemd and install some appropriate service files. With systemd, you can edit the commandline arguments of the thinkfan service with `systemctl edit thinkfan`. With OpenRC, we install only a plain initscript (edit `/etc/init.d/thinkfan` to change options). # Documentation - Run `thinkfan -h` - Manpages: `thinkfan(1)`, `thinkfan.conf(5)` - Example configs: https://github.com/vmatare/thinkfan/tree/master/examples - Linux kernel hwmon doc: https://www.kernel.org/doc/html/latest/hwmon/sysfs-interface.html - Linux kernel thinkpad_acpi doc: https://www.kernel.org/doc/html/latest/admin-guide/laptops/thinkpad-acpi.html - If all fails: https://github.com/vmatare/thinkfan/issues thinkfan-1.3.1/examples/000077500000000000000000000000001417751172400151455ustar00rootroot00000000000000thinkfan-1.3.1/examples/thinkfan.yaml000066400000000000000000000155301417751172400176370ustar00rootroot00000000000000############################################################################## # thinkfan Example Config File # ============================ # # Please read the config manpage thinkfan.conf(5) before playing around with # this. # # This is NOT a working config file that can just be copied. It is only meant # to give a rough idea what can be done. In particular, don't copy & paste the # fan speed config! Think about what you're doing. # # If you don't know what temperatures are right for your system, you should # not be using thinkfan! ############################################################################## ############################################################################## # Sensor Drivers and Temperature Inputs # ===================================== # # ATTENTION: The order in which sensors are specified here is significant when # specifying the fan speeds further below! # # There are multiple ways in which a temperature input can be specified. An # example for each is given below. # # The "correction:" and "optional:" keywords may be specified on any type of # sensor. sensors: # hwmon: Full path to a temperature file (single sensor). # ======================================================= # Disadvantage is that the index in "hwmon0" depends on the load order of # the driver modules, which may change across bootups on some systems. - hwmon: /sys/class/hwmon/hwmon0/temp1_input # hwmon: Path to a complete driver folder # ======================================= # Individual sensors need to be picked out with the "indices:" keyword. # This can be used with a stable path that does not depend on driver load # order. However certain drivers may not appear under such a stable path. - hwmon: /sys/devices/pci0000:00/0000:00:03.1/0000:27:00.0/hwmon indices: [1, 2, 5, 6] # adds 4 temperature sensors correction: [0, 0, 0, -5] # add -5 °C to temp6_input # hwmon: Base path with name-based search # ======================================= # Thinkfan will search under the given path for a hwmon driver that has a # file called "name" which contains the given name. This method should work # with all hwmon drivers and is robust against driver load order. - hwmon: /sys/class/hwmon name: k10temp indices: [1] # Sensors can also be optional, e.g. in case of removable hardware - hwmon: /sys/class/block/sdc/device/hwmon indices: [1] optional: true # don't exit if the sensor can't be read # atasmart: Read the temperature from a hard disk via S.M.A.R.T # ============================================================= # Note that this is unreasonably CPU-intensive. Since Linux 5.6, the kernel # can report the temperatures of hard disks via the hwmon interface (see the # example above), which should be preferred if available. # # This is only available if thinkfan was compiled with USE_ATASMART enabled. - atasmart: /dev/sda # tpacpi: Legacy interface to the thinkpad_acpi driver # ==================================================== # Particularly on older Thinkpad laptops, this interface may give access to # 8-16 temperature sensors, but it may be hard to tell where/what exactly # they measure. # Some documentation for older models may be found at the thinkpad wiki: # https://www.thinkwiki.org/wiki/Thermal_Sensors # # Note that the hwmon interface is to be preferred nowadays. - tpacpi: /proc/acpi/ibm/thermal # Some of the temperature entries in /proc/acpi/ibm/thermal may be # irrelevant or unused, so individual ones can be selected: indices: [1, 2, 3, 4] # nvml: The proprietary nVidia driver # =================================== # Temperatures can be read directly from nVidia GPUs that run with the # proprietary driver. The "nvml:" entry must specify the PCI bus ID of the # GPU (can be found with lspci) # # Note that this does not work with the open-source "nouveau" driver. Open # source drivers should support the hwmon interface instead (see above). - nvml: 27:00.0 ############################################################################## ############################################################################## # Fan Drivers # =========== # # Currently, thinkfan supports only one fan, but support for multiple fans is # in development and will be released soon. For the time being, the examples # given below are mutually exclusive. # fans: # hwmon: Full path to a PWM file # ============================== # Also subject to the potential problem with driver load order (see above) - hwmon: /sys/class/hwmon/hwmon0/pwm1 # hwmon: Path to a complete driver folder # ======================================= - hwmon: /sys/class/graphics/fb0/device/hwmon indices: [1] # Use pwm1 # hwmon: Base path with name-based search # ======================================= - hwmon: /sys/class/hwmon name: amdgpu indices: [1] # tpacpi: Thinkpad-specific fan interface # ======================================= # Currently, this is the only way to use disengaged and automatic mode on # thinkpads. - tpacpi: /proc/acpi/ibm/fan ############################################################################## ############################################################################## # Fan Speeds (simple mode) # ======================== # # In simple mode, each entry is a [FANSPEED, LOWER_LIMIT, UPPER_LIMIT] tuple. # This is a quick way to configure a small system like a laptop, where the # temperature ratings for all monitored devices are similar. Only the highest # temperature found across all sensors will be compared against these limits. # All other temperatures are ignored. # # Correction values on individual sensors (see above) may be used to equalize # small discrepancies in temperature ratings. # # The FANSPEED values in this example are valid for the thinkpad_acpi fan # driver only (see above) # levels: - [0, 0, 50] - ["level auto", 45, 75] - ["level disengaged", 70, 255] ############################################################################## ############################################################################## # Fan Speeds (detailed mode) # ========================== # # It is generally advisable to configure the temperature limits for each # sensor individually. # # The speed values used here range from 0 to 255, which is valid for the PWM # control files used by hwmon-based drivers. # # The temperatures specified in upper_limit and lower_limit apply to the # sensors in the same order in which they were specified in the "sensors:" # section above, and their length must match the total number of sensors that # have been configured. # levels: - speed: 0 upper_limit: [50, 50, 50] - speed: 100 lower_limit: [45, 45, 45] upper_limit: [65, 65, 65] - speed: 255 lower_limit: [60, 60, 60] ############################################################################## thinkfan-1.3.1/include/000077500000000000000000000000001417751172400147525ustar00rootroot00000000000000thinkfan-1.3.1/include/nvidia/000077500000000000000000000000001417751172400162245ustar00rootroot00000000000000thinkfan-1.3.1/include/nvidia/gdk/000077500000000000000000000000001417751172400167715ustar00rootroot00000000000000thinkfan-1.3.1/include/nvidia/gdk/nvml.h000066400000000000000000005540131417751172400201260ustar00rootroot00000000000000/* * Copyright 1993-2015 NVIDIA Corporation. All rights reserved. * * NOTICE TO USER: * * This source code is subject to NVIDIA ownership rights under U.S. and * international Copyright laws. Users and possessors of this source code * are hereby granted a nonexclusive, royalty-free license to use this code * in individual and commercial software. * * NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE * CODE FOR ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR * IMPLIED WARRANTY OF ANY KIND. NVIDIA DISCLAIMS ALL WARRANTIES WITH * REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE. * IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL, * OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE * OR PERFORMANCE OF THIS SOURCE CODE. * * U.S. Government End Users. This source code is a "commercial item" as * that term is defined at 48 C.F.R. 2.101 (OCT 1995), consisting of * "commercial computer software" and "commercial computer software * documentation" as such terms are used in 48 C.F.R. 12.212 (SEPT 1995) * and is provided to the U.S. Government only as a commercial end item. * Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through * 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the * source code with only those rights set forth herein. * * Any use of this source code in individual and commercial software must * include, in the user documentation and internal comments to the code, * the above Disclaimer and U.S. Government End Users Notice. */ /* NVML API Reference The NVIDIA Management Library (NVML) is a C-based programmatic interface for monitoring and managing various states within NVIDIA Tesla &tm; GPUs. It is intended to be a platform for building 3rd party applications, and is also the underlying library for the NVIDIA-supported nvidia-smi tool. NVML is thread-safe so it is safe to make simultaneous NVML calls from multiple threads. API Documentation Supported platforms: - Windows: Windows Server 2008 R2 64bit, Windows Server 2012 R2 64bit, Windows 7 64bit, Windows 8 64bit - Linux: 32-bit and 64-bit - Hypervisors: Windows Server 2008R2/2012 Hyper-V 64bit, Citrix XenServer 6.2 SP1+, VMware ESX 5.1/5.5 Supported products: - Full Support - All Tesla products, starting with the Fermi architecture - All Quadro products, starting with the Fermi architecture - All GRID products, starting with the Kepler architecture - Selected GeForce Titan products - Limited Support - All Geforce products, starting with the Fermi architecture The NVML library can be found at \%ProgramW6432\%\\"NVIDIA Corporation"\\NVSMI\\ on Windows. It is not be added to the system path by default. To dynamically link to NVML, add this path to the PATH environmental variable. To dynamically load NVML, call LoadLibrary with this path. On Linux the NVML library will be found on the standard library path. For 64 bit Linux, both the 32 bit and 64 bit NVML libraries will be installed. Online documentation for this library is available at http://docs.nvidia.com/deploy/nvml-api/index.html */ #ifndef __nvml_nvml_h__ #define __nvml_nvml_h__ #ifdef __cplusplus extern "C" { #endif /* * On Windows, set up methods for DLL export * define NVML_STATIC_IMPORT when using nvml_loader library */ #if defined _WINDOWS #if !defined NVML_STATIC_IMPORT #if defined NVML_LIB_EXPORT #define DECLDIR __declspec(dllexport) #else #define DECLDIR __declspec(dllimport) #endif #else #define DECLDIR #endif #else #define DECLDIR #endif /** * NVML API versioning support */ #define NVML_API_VERSION 7 #define NVML_API_VERSION_STR "7" #define nvmlInit nvmlInit_v2 #define nvmlDeviceGetPciInfo nvmlDeviceGetPciInfo_v2 #define nvmlDeviceGetCount nvmlDeviceGetCount_v2 #define nvmlDeviceGetHandleByIndex nvmlDeviceGetHandleByIndex_v2 #define nvmlDeviceGetHandleByPciBusId nvmlDeviceGetHandleByPciBusId_v2 /***************************************************************************************************/ /** @defgroup nvmlDeviceStructs Device Structs * @{ */ /***************************************************************************************************/ /** * Special constant that some fields take when they are not available. * Used when only part of the struct is not available. * * Each structure explicitly states when to check for this value. */ #define NVML_VALUE_NOT_AVAILABLE (-1) typedef struct nvmlDevice_st* nvmlDevice_t; /** * Buffer size guaranteed to be large enough for pci bus id */ #define NVML_DEVICE_PCI_BUS_ID_BUFFER_SIZE 16 /** * PCI information about a GPU device. */ typedef struct nvmlPciInfo_st { char busId[NVML_DEVICE_PCI_BUS_ID_BUFFER_SIZE]; //!< The tuple domain:bus:device.function PCI identifier (& NULL terminator) unsigned int domain; //!< The PCI domain on which the device's bus resides, 0 to 0xffff unsigned int bus; //!< The bus on which the device resides, 0 to 0xff unsigned int device; //!< The device's id on the bus, 0 to 31 unsigned int pciDeviceId; //!< The combined 16-bit device id and 16-bit vendor id // Added in NVML 2.285 API unsigned int pciSubSystemId; //!< The 32-bit Sub System Device ID // NVIDIA reserved for internal use only unsigned int reserved0; unsigned int reserved1; unsigned int reserved2; unsigned int reserved3; } nvmlPciInfo_t; /** * Detailed ECC error counts for a device. * * @deprecated Different GPU families can have different memory error counters * See \ref nvmlDeviceGetMemoryErrorCounter */ typedef struct nvmlEccErrorCounts_st { unsigned long long l1Cache; //!< L1 cache errors unsigned long long l2Cache; //!< L2 cache errors unsigned long long deviceMemory; //!< Device memory errors unsigned long long registerFile; //!< Register file errors } nvmlEccErrorCounts_t; /** * Utilization information for a device. * Each sample period may be between 1 second and 1/6 second, depending on the product being queried. */ typedef struct nvmlUtilization_st { unsigned int gpu; //!< Percent of time over the past sample period during which one or more kernels was executing on the GPU unsigned int memory; //!< Percent of time over the past sample period during which global (device) memory was being read or written } nvmlUtilization_t; /** * Memory allocation information for a device. */ typedef struct nvmlMemory_st { unsigned long long total; //!< Total installed FB memory (in bytes) unsigned long long free; //!< Unallocated FB memory (in bytes) unsigned long long used; //!< Allocated FB memory (in bytes). Note that the driver/GPU always sets aside a small amount of memory for bookkeeping } nvmlMemory_t; /** * BAR1 Memory allocation Information for a device */ typedef struct nvmlBAR1Memory_st { unsigned long long bar1Total; //!< Total BAR1 Memory (in bytes) unsigned long long bar1Free; //!< Unallocated BAR1 Memory (in bytes) unsigned long long bar1Used; //!< Allocated Used Memory (in bytes) }nvmlBAR1Memory_t; /** * Information about running compute processes on the GPU */ typedef struct nvmlProcessInfo_st { unsigned int pid; //!< Process ID unsigned long long usedGpuMemory; //!< Amount of used GPU memory in bytes. //! Under WDDM, \ref NVML_VALUE_NOT_AVAILABLE is always reported //! because Windows KMD manages all the memory and not the NVIDIA driver } nvmlProcessInfo_t; /** * Enum to represent type of bridge chip */ typedef enum nvmlBridgeChipType_enum { NVML_BRIDGE_CHIP_PLX = 0, NVML_BRIDGE_CHIP_BRO4 = 1 }nvmlBridgeChipType_t; /** * Maximum limit on Physical Bridges per Board */ #define NVML_MAX_PHYSICAL_BRIDGE (128) /** * Information about the Bridge Chip Firmware */ typedef struct nvmlBridgeChipInfo_st { nvmlBridgeChipType_t type; //!< Type of Bridge Chip unsigned int fwVersion; //!< Firmware Version. 0=Version is unavailable }nvmlBridgeChipInfo_t; /** * This structure stores the complete Hierarchy of the Bridge Chip within the board. The immediate * bridge is stored at index 0 of bridgeInfoList, parent to immediate bridge is at index 1 and so forth. */ typedef struct nvmlBridgeChipHierarchy_st { unsigned char bridgeCount; //!< Number of Bridge Chips on the Board nvmlBridgeChipInfo_t bridgeChipInfo[NVML_MAX_PHYSICAL_BRIDGE]; //!< Hierarchy of Bridge Chips on the board }nvmlBridgeChipHierarchy_t; /** * Represents Type of Sampling Event */ typedef enum nvmlSamplingType_enum { NVML_TOTAL_POWER_SAMPLES = 0, //!< To represent total power drawn by GPU NVML_GPU_UTILIZATION_SAMPLES = 1, //!< To represent percent of time during which one or more kernels was executing on the GPU NVML_MEMORY_UTILIZATION_SAMPLES = 2, //!< To represent percent of time during which global (device) memory was being read or written NVML_ENC_UTILIZATION_SAMPLES = 3, //!< To represent percent of time during which NVENC remains busy NVML_DEC_UTILIZATION_SAMPLES = 4, //!< To represent percent of time during which NVDEC remains busy NVML_PROCESSOR_CLK_SAMPLES = 5, //!< To represent processor clock samples NVML_MEMORY_CLK_SAMPLES = 6, //!< To represent memory clock samples // Keep this last NVML_SAMPLINGTYPE_COUNT }nvmlSamplingType_t; /** * Represents the queryable PCIe utilization counters */ typedef enum nvmlPcieUtilCounter_enum { NVML_PCIE_UTIL_TX_BYTES = 0, // 1KB granularity NVML_PCIE_UTIL_RX_BYTES = 1, // 1KB granularity // Keep this last NVML_PCIE_UTIL_COUNT } nvmlPcieUtilCounter_t; /** * Represents the type for sample value returned */ typedef enum nvmlValueType_enum { NVML_VALUE_TYPE_DOUBLE = 0, NVML_VALUE_TYPE_UNSIGNED_INT = 1, NVML_VALUE_TYPE_UNSIGNED_LONG = 2, NVML_VALUE_TYPE_UNSIGNED_LONG_LONG = 3, // Keep this last NVML_VALUE_TYPE_COUNT }nvmlValueType_t; /** * Union to represent different types of Value */ typedef union nvmlValue_st { double dVal; //!< If the value is double unsigned int uiVal; //!< If the value is unsigned int unsigned long ulVal; //!< If the value is unsigned long unsigned long long ullVal; //!< If the value is unsigned long long }nvmlValue_t; /** * Information for Sample */ typedef struct nvmlSample_st { unsigned long long timeStamp; //!< CPU Timestamp in microseconds nvmlValue_t sampleValue; //!< Sample Value }nvmlSample_t; /** * Represents type of perf policy for which violation times can be queried */ typedef enum nvmlPerfPolicyType_enum { NVML_PERF_POLICY_POWER = 0, NVML_PERF_POLICY_THERMAL = 1, // Keep this last NVML_PERF_POLICY_COUNT }nvmlPerfPolicyType_t; /** * Struct to hold perf policy violation status data */ typedef struct nvmlViolationTime_st { unsigned long long referenceTime; //!< referenceTime represents CPU timestamp in microseconds unsigned long long violationTime; //!< violationTime in Nanoseconds }nvmlViolationTime_t; /** @} */ /***************************************************************************************************/ /** @defgroup nvmlDeviceEnumvs Device Enums * @{ */ /***************************************************************************************************/ /** * Generic enable/disable enum. */ typedef enum nvmlEnableState_enum { NVML_FEATURE_DISABLED = 0, //!< Feature disabled NVML_FEATURE_ENABLED = 1 //!< Feature enabled } nvmlEnableState_t; //! Generic flag used to specify the default behavior of some functions. See description of particular functions for details. #define nvmlFlagDefault 0x00 //! Generic flag used to force some behavior. See description of particular functions for details. #define nvmlFlagForce 0x01 /** * * The Brand of the GPU * */ typedef enum nvmlBrandType_enum { NVML_BRAND_UNKNOWN = 0, NVML_BRAND_QUADRO = 1, NVML_BRAND_TESLA = 2, NVML_BRAND_NVS = 3, NVML_BRAND_GRID = 4, NVML_BRAND_GEFORCE = 5, // Keep this last NVML_BRAND_COUNT } nvmlBrandType_t; /** * Temperature thresholds. */ typedef enum nvmlTemperatureThresholds_enum { NVML_TEMPERATURE_THRESHOLD_SHUTDOWN = 0, // Temperature at which the GPU will shut down // for HW protection NVML_TEMPERATURE_THRESHOLD_SLOWDOWN = 1, // Temperature at which the GPU will begin slowdown // Keep this last NVML_TEMPERATURE_THRESHOLD_COUNT } nvmlTemperatureThresholds_t; /** * Temperature sensors. */ typedef enum nvmlTemperatureSensors_enum { NVML_TEMPERATURE_GPU = 0, //!< Temperature sensor for the GPU die // Keep this last NVML_TEMPERATURE_COUNT } nvmlTemperatureSensors_t; /** * Compute mode. * * NVML_COMPUTEMODE_EXCLUSIVE_PROCESS was added in CUDA 4.0. * Earlier CUDA versions supported a single exclusive mode, * which is equivalent to NVML_COMPUTEMODE_EXCLUSIVE_THREAD in CUDA 4.0 and beyond. */ typedef enum nvmlComputeMode_enum { NVML_COMPUTEMODE_DEFAULT = 0, //!< Default compute mode -- multiple contexts per device NVML_COMPUTEMODE_EXCLUSIVE_THREAD = 1, //!< Compute-exclusive-thread mode -- only one context per device, usable from one thread at a time NVML_COMPUTEMODE_PROHIBITED = 2, //!< Compute-prohibited mode -- no contexts per device NVML_COMPUTEMODE_EXCLUSIVE_PROCESS = 3, //!< Compute-exclusive-process mode -- only one context per device, usable from multiple threads at a time // Keep this last NVML_COMPUTEMODE_COUNT } nvmlComputeMode_t; /** * ECC bit types. * * @deprecated See \ref nvmlMemoryErrorType_t for a more flexible type */ #define nvmlEccBitType_t nvmlMemoryErrorType_t /** * Single bit ECC errors * * @deprecated Mapped to \ref NVML_MEMORY_ERROR_TYPE_CORRECTED */ #define NVML_SINGLE_BIT_ECC NVML_MEMORY_ERROR_TYPE_CORRECTED /** * Double bit ECC errors * * @deprecated Mapped to \ref NVML_MEMORY_ERROR_TYPE_UNCORRECTED */ #define NVML_DOUBLE_BIT_ECC NVML_MEMORY_ERROR_TYPE_UNCORRECTED /** * Memory error types */ typedef enum nvmlMemoryErrorType_enum { /** * A memory error that was corrected * * For ECC errors, these are single bit errors * For Texture memory, these are errors fixed by resend */ NVML_MEMORY_ERROR_TYPE_CORRECTED = 0, /** * A memory error that was not corrected * * For ECC errors, these are double bit errors * For Texture memory, these are errors where the resend fails */ NVML_MEMORY_ERROR_TYPE_UNCORRECTED = 1, // Keep this last NVML_MEMORY_ERROR_TYPE_COUNT //!< Count of memory error types } nvmlMemoryErrorType_t; /** * ECC counter types. * * Note: Volatile counts are reset each time the driver loads. On Windows this is once per boot. On Linux this can be more frequent. * On Linux the driver unloads when no active clients exist. If persistence mode is enabled or there is always a driver * client active (e.g. X11), then Linux also sees per-boot behavior. If not, volatile counts are reset each time a compute app * is run. */ typedef enum nvmlEccCounterType_enum { NVML_VOLATILE_ECC = 0, //!< Volatile counts are reset each time the driver loads. NVML_AGGREGATE_ECC = 1, //!< Aggregate counts persist across reboots (i.e. for the lifetime of the device) // Keep this last NVML_ECC_COUNTER_TYPE_COUNT //!< Count of memory counter types } nvmlEccCounterType_t; /** * Clock types. * * All speeds are in Mhz. */ typedef enum nvmlClockType_enum { NVML_CLOCK_GRAPHICS = 0, //!< Graphics clock domain NVML_CLOCK_SM = 1, //!< SM clock domain NVML_CLOCK_MEM = 2, //!< Memory clock domain // Keep this last NVML_CLOCK_COUNT //usedGpuMemory is not supported unsigned long long time; //!< Amount of time in ms during which the compute context was active unsigned int reserved[8]; } nvmlAccountingStats_t; /** @} */ /***************************************************************************************************/ /** @defgroup nvmlInitializationAndCleanup Initialization and Cleanup * This chapter describes the methods that handle NVML initialization and cleanup. * It is the user's responsibility to call \ref nvmlInit() before calling any other methods, and * nvmlShutdown() once NVML is no longer being used. * @{ */ /***************************************************************************************************/ /** * Initialize NVML, but don't initialize any GPUs yet. * * \note In NVML 5.319 new nvmlInit_v2 has replaced nvmlInit"_v1" (default in NVML 4.304 and older) that * did initialize all GPU devices in the system. * * This allows NVML to communicate with a GPU * when other GPUs in the system are unstable or in a bad state. When using this API, GPUs are * discovered and initialized in nvmlDeviceGetHandleBy* functions instead. * * \note To contrast nvmlInit_v2 with nvmlInit"_v1", NVML 4.304 nvmlInit"_v1" will fail when any detected GPU is in * a bad or unstable state. * * For all products. * * This method, should be called once before invoking any other methods in the library. * A reference count of the number of initializations is maintained. Shutdown only occurs * when the reference count reaches zero. * * @return * - \ref NVML_SUCCESS if NVML has been properly initialized * - \ref NVML_ERROR_DRIVER_NOT_LOADED if NVIDIA driver is not running * - \ref NVML_ERROR_NO_PERMISSION if NVML does not have permission to talk to the driver * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlInit(void); /** * Shut down NVML by releasing all GPU resources previously allocated with \ref nvmlInit(). * * For all products. * * This method should be called after NVML work is done, once for each call to \ref nvmlInit() * A reference count of the number of initializations is maintained. Shutdown only occurs * when the reference count reaches zero. For backwards compatibility, no error is reported if * nvmlShutdown() is called more times than nvmlInit(). * * @return * - \ref NVML_SUCCESS if NVML has been properly shut down * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlShutdown(void); /** @} */ /***************************************************************************************************/ /** @defgroup nvmlErrorReporting Error reporting * This chapter describes helper functions for error reporting routines. * @{ */ /***************************************************************************************************/ /** * Helper method for converting NVML error codes into readable strings. * * For all products. * * @param result NVML error code to convert * * @return String representation of the error. * */ const DECLDIR char* nvmlErrorString(nvmlReturn_t result); /** @} */ /***************************************************************************************************/ /** @defgroup nvmlConstants Constants * @{ */ /***************************************************************************************************/ /** * Buffer size guaranteed to be large enough for \ref nvmlDeviceGetInforomVersion and \ref nvmlDeviceGetInforomImageVersion */ #define NVML_DEVICE_INFOROM_VERSION_BUFFER_SIZE 16 /** * Buffer size guaranteed to be large enough for \ref nvmlDeviceGetUUID */ #define NVML_DEVICE_UUID_BUFFER_SIZE 80 /** * Buffer size guaranteed to be large enough for \ref nvmlSystemGetDriverVersion */ #define NVML_SYSTEM_DRIVER_VERSION_BUFFER_SIZE 80 /** * Buffer size guaranteed to be large enough for \ref nvmlSystemGetNVMLVersion */ #define NVML_SYSTEM_NVML_VERSION_BUFFER_SIZE 80 /** * Buffer size guaranteed to be large enough for \ref nvmlDeviceGetName */ #define NVML_DEVICE_NAME_BUFFER_SIZE 64 /** * Buffer size guaranteed to be large enough for \ref nvmlDeviceGetSerial */ #define NVML_DEVICE_SERIAL_BUFFER_SIZE 30 /** * Buffer size guaranteed to be large enough for \ref nvmlDeviceGetVbiosVersion */ #define NVML_DEVICE_VBIOS_VERSION_BUFFER_SIZE 32 /** @} */ /***************************************************************************************************/ /** @defgroup nvmlSystemQueries System Queries * This chapter describes the queries that NVML can perform against the local system. These queries * are not device-specific. * @{ */ /***************************************************************************************************/ /** * Retrieves the version of the system's graphics driver. * * For all products. * * The version identifier is an alphanumeric string. It will not exceed 80 characters in length * (including the NULL terminator). See \ref nvmlConstants::NVML_SYSTEM_DRIVER_VERSION_BUFFER_SIZE. * * @param version Reference in which to return the version identifier * @param length The maximum allowed length of the string returned in \a version * * @return * - \ref NVML_SUCCESS if \a version has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a version is NULL * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small */ nvmlReturn_t DECLDIR nvmlSystemGetDriverVersion(char *version, unsigned int length); /** * Retrieves the version of the NVML library. * * For all products. * * The version identifier is an alphanumeric string. It will not exceed 80 characters in length * (including the NULL terminator). See \ref nvmlConstants::NVML_SYSTEM_NVML_VERSION_BUFFER_SIZE. * * @param version Reference in which to return the version identifier * @param length The maximum allowed length of the string returned in \a version * * @return * - \ref NVML_SUCCESS if \a version has been set * - \ref NVML_ERROR_INVALID_ARGUMENT if \a version is NULL * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small */ nvmlReturn_t DECLDIR nvmlSystemGetNVMLVersion(char *version, unsigned int length); /** * Gets name of the process with provided process id * * For all products. * * Returned process name is cropped to provided length. * name string is encoded in ANSI. * * @param pid The identifier of the process * @param name Reference in which to return the process name * @param length The maximum allowed length of the string returned in \a name * * @return * - \ref NVML_SUCCESS if \a name has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a name is NULL or \a length is 0. * - \ref NVML_ERROR_NOT_FOUND if process doesn't exists * - \ref NVML_ERROR_NO_PERMISSION if the user doesn't have permission to perform this operation * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlSystemGetProcessName(unsigned int pid, char *name, unsigned int length); /** @} */ /***************************************************************************************************/ /** @defgroup nvmlUnitQueries Unit Queries * This chapter describes that queries that NVML can perform against each unit. For S-class systems only. * In each case the device is identified with an nvmlUnit_t handle. This handle is obtained by * calling \ref nvmlUnitGetHandleByIndex(). * @{ */ /***************************************************************************************************/ /** * Retrieves the number of units in the system. * * For S-class products. * * @param unitCount Reference in which to return the number of units * * @return * - \ref NVML_SUCCESS if \a unitCount has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a unitCount is NULL * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlUnitGetCount(unsigned int *unitCount); /** * Acquire the handle for a particular unit, based on its index. * * For S-class products. * * Valid indices are derived from the \a unitCount returned by \ref nvmlUnitGetCount(). * For example, if \a unitCount is 2 the valid indices are 0 and 1, corresponding to UNIT 0 and UNIT 1. * * The order in which NVML enumerates units has no guarantees of consistency between reboots. * * @param index The index of the target unit, >= 0 and < \a unitCount * @param unit Reference in which to return the unit handle * * @return * - \ref NVML_SUCCESS if \a unit has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a index is invalid or \a unit is NULL * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlUnitGetHandleByIndex(unsigned int index, nvmlUnit_t *unit); /** * Retrieves the static information associated with a unit. * * For S-class products. * * See \ref nvmlUnitInfo_t for details on available unit info. * * @param unit The identifier of the target unit * @param info Reference in which to return the unit information * * @return * - \ref NVML_SUCCESS if \a info has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a unit is invalid or \a info is NULL */ nvmlReturn_t DECLDIR nvmlUnitGetUnitInfo(nvmlUnit_t unit, nvmlUnitInfo_t *info); /** * Retrieves the LED state associated with this unit. * * For S-class products. * * See \ref nvmlLedState_t for details on allowed states. * * @param unit The identifier of the target unit * @param state Reference in which to return the current LED state * * @return * - \ref NVML_SUCCESS if \a state has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a unit is invalid or \a state is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if this is not an S-class product * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlUnitSetLedState() */ nvmlReturn_t DECLDIR nvmlUnitGetLedState(nvmlUnit_t unit, nvmlLedState_t *state); /** * Retrieves the PSU stats for the unit. * * For S-class products. * * See \ref nvmlPSUInfo_t for details on available PSU info. * * @param unit The identifier of the target unit * @param psu Reference in which to return the PSU information * * @return * - \ref NVML_SUCCESS if \a psu has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a unit is invalid or \a psu is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if this is not an S-class product * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlUnitGetPsuInfo(nvmlUnit_t unit, nvmlPSUInfo_t *psu); /** * Retrieves the temperature readings for the unit, in degrees C. * * For S-class products. * * Depending on the product, readings may be available for intake (type=0), * exhaust (type=1) and board (type=2). * * @param unit The identifier of the target unit * @param type The type of reading to take * @param temp Reference in which to return the intake temperature * * @return * - \ref NVML_SUCCESS if \a temp has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a unit or \a type is invalid or \a temp is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if this is not an S-class product * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlUnitGetTemperature(nvmlUnit_t unit, unsigned int type, unsigned int *temp); /** * Retrieves the fan speed readings for the unit. * * For S-class products. * * See \ref nvmlUnitFanSpeeds_t for details on available fan speed info. * * @param unit The identifier of the target unit * @param fanSpeeds Reference in which to return the fan speed information * * @return * - \ref NVML_SUCCESS if \a fanSpeeds has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a unit is invalid or \a fanSpeeds is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if this is not an S-class product * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlUnitGetFanSpeedInfo(nvmlUnit_t unit, nvmlUnitFanSpeeds_t *fanSpeeds); /** * Retrieves the set of GPU devices that are attached to the specified unit. * * For S-class products. * * The \a deviceCount argument is expected to be set to the size of the input \a devices array. * * @param unit The identifier of the target unit * @param deviceCount Reference in which to provide the \a devices array size, and * to return the number of attached GPU devices * @param devices Reference in which to return the references to the attached GPU devices * * @return * - \ref NVML_SUCCESS if \a deviceCount and \a devices have been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a deviceCount indicates that the \a devices array is too small * - \ref NVML_ERROR_INVALID_ARGUMENT if \a unit is invalid, either of \a deviceCount or \a devices is NULL * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlUnitGetDevices(nvmlUnit_t unit, unsigned int *deviceCount, nvmlDevice_t *devices); /** * Retrieves the IDs and firmware versions for any Host Interface Cards (HICs) in the system. * * For S-class products. * * The \a hwbcCount argument is expected to be set to the size of the input \a hwbcEntries array. * The HIC must be connected to an S-class system for it to be reported by this function. * * @param hwbcCount Size of hwbcEntries array * @param hwbcEntries Array holding information about hwbc * * @return * - \ref NVML_SUCCESS if \a hwbcCount and \a hwbcEntries have been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if either \a hwbcCount or \a hwbcEntries is NULL * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a hwbcCount indicates that the \a hwbcEntries array is too small */ nvmlReturn_t DECLDIR nvmlSystemGetHicVersion(unsigned int *hwbcCount, nvmlHwbcEntry_t *hwbcEntries); /** @} */ /***************************************************************************************************/ /** @defgroup nvmlDeviceQueries Device Queries * This chapter describes that queries that NVML can perform against each device. * In each case the device is identified with an nvmlDevice_t handle. This handle is obtained by * calling one of \ref nvmlDeviceGetHandleByIndex(), \ref nvmlDeviceGetHandleBySerial(), * \ref nvmlDeviceGetHandleByPciBusId(). or \ref nvmlDeviceGetHandleByUUID(). * @{ */ /***************************************************************************************************/ /** * Retrieves the number of compute devices in the system. A compute device is a single GPU. * * For all products. * * Note: New nvmlDeviceGetCount_v2 (default in NVML 5.319) returns count of all devices in the system * even if nvmlDeviceGetHandleByIndex_v2 returns NVML_ERROR_NO_PERMISSION for such device. * Update your code to handle this error, or use NVML 4.304 or older nvml header file. * For backward binary compatibility reasons _v1 version of the API is still present in the shared * library. * Old _v1 version of nvmlDeviceGetCount doesn't count devices that NVML has no permission to talk to. * * @param deviceCount Reference in which to return the number of accessible devices * * @return * - \ref NVML_SUCCESS if \a deviceCount has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a deviceCount is NULL * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetCount(unsigned int *deviceCount); /** * Acquire the handle for a particular device, based on its index. * * For all products. * * Valid indices are derived from the \a accessibleDevices count returned by * \ref nvmlDeviceGetCount(). For example, if \a accessibleDevices is 2 the valid indices * are 0 and 1, corresponding to GPU 0 and GPU 1. * * The order in which NVML enumerates devices has no guarantees of consistency between reboots. For that reason it * is recommended that devices be looked up by their PCI ids or UUID. See * \ref nvmlDeviceGetHandleByUUID() and \ref nvmlDeviceGetHandleByPciBusId(). * * Note: The NVML index may not correlate with other APIs, such as the CUDA device index. * * Starting from NVML 5, this API causes NVML to initialize the target GPU * NVML may initialize additional GPUs if: * - The target GPU is an SLI slave * * Note: New nvmlDeviceGetCount_v2 (default in NVML 5.319) returns count of all devices in the system * even if nvmlDeviceGetHandleByIndex_v2 returns NVML_ERROR_NO_PERMISSION for such device. * Update your code to handle this error, or use NVML 4.304 or older nvml header file. * For backward binary compatibility reasons _v1 version of the API is still present in the shared * library. * Old _v1 version of nvmlDeviceGetCount doesn't count devices that NVML has no permission to talk to. * * This means that nvmlDeviceGetHandleByIndex_v2 and _v1 can return different devices for the same index. * If you don't touch macros that map old (_v1) versions to _v2 versions at the top of the file you don't * need to worry about that. * * @param index The index of the target GPU, >= 0 and < \a accessibleDevices * @param device Reference in which to return the device handle * * @return * - \ref NVML_SUCCESS if \a device has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a index is invalid or \a device is NULL * - \ref NVML_ERROR_INSUFFICIENT_POWER if any attached devices have improperly attached external power cables * - \ref NVML_ERROR_NO_PERMISSION if the user doesn't have permission to talk to this device * - \ref NVML_ERROR_IRQ_ISSUE if NVIDIA kernel detected an interrupt issue with the attached GPUs * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetIndex * @see nvmlDeviceGetCount */ nvmlReturn_t DECLDIR nvmlDeviceGetHandleByIndex(unsigned int index, nvmlDevice_t *device); /** * Acquire the handle for a particular device, based on its board serial number. * * For Fermi &tm; or newer fully supported devices. * * This number corresponds to the value printed directly on the board, and to the value returned by * \ref nvmlDeviceGetSerial(). * * @deprecated Since more than one GPU can exist on a single board this function is deprecated in favor * of \ref nvmlDeviceGetHandleByUUID. * For dual GPU boards this function will return NVML_ERROR_INVALID_ARGUMENT. * * Starting from NVML 5, this API causes NVML to initialize the target GPU * NVML may initialize additional GPUs as it searches for the target GPU * * @param serial The board serial number of the target GPU * @param device Reference in which to return the device handle * * @return * - \ref NVML_SUCCESS if \a device has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a serial is invalid, \a device is NULL or more than one * device has the same serial (dual GPU boards) * - \ref NVML_ERROR_NOT_FOUND if \a serial does not match a valid device on the system * - \ref NVML_ERROR_INSUFFICIENT_POWER if any attached devices have improperly attached external power cables * - \ref NVML_ERROR_IRQ_ISSUE if NVIDIA kernel detected an interrupt issue with the attached GPUs * - \ref NVML_ERROR_GPU_IS_LOST if any GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetSerial * @see nvmlDeviceGetHandleByUUID */ nvmlReturn_t DECLDIR nvmlDeviceGetHandleBySerial(const char *serial, nvmlDevice_t *device); /** * Acquire the handle for a particular device, based on its globally unique immutable UUID associated with each device. * * For all products. * * @param uuid The UUID of the target GPU * @param device Reference in which to return the device handle * * Starting from NVML 5, this API causes NVML to initialize the target GPU * NVML may initialize additional GPUs as it searches for the target GPU * * @return * - \ref NVML_SUCCESS if \a device has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a uuid is invalid or \a device is null * - \ref NVML_ERROR_NOT_FOUND if \a uuid does not match a valid device on the system * - \ref NVML_ERROR_INSUFFICIENT_POWER if any attached devices have improperly attached external power cables * - \ref NVML_ERROR_IRQ_ISSUE if NVIDIA kernel detected an interrupt issue with the attached GPUs * - \ref NVML_ERROR_GPU_IS_LOST if any GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetUUID */ nvmlReturn_t DECLDIR nvmlDeviceGetHandleByUUID(const char *uuid, nvmlDevice_t *device); /** * Acquire the handle for a particular device, based on its PCI bus id. * * For all products. * * This value corresponds to the nvmlPciInfo_t::busId returned by \ref nvmlDeviceGetPciInfo(). * * Starting from NVML 5, this API causes NVML to initialize the target GPU * NVML may initialize additional GPUs if: * - The target GPU is an SLI slave * * \note NVML 4.304 and older version of nvmlDeviceGetHandleByPciBusId"_v1" returns NVML_ERROR_NOT_FOUND * instead of NVML_ERROR_NO_PERMISSION. * * @param pciBusId The PCI bus id of the target GPU * @param device Reference in which to return the device handle * * @return * - \ref NVML_SUCCESS if \a device has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a pciBusId is invalid or \a device is NULL * - \ref NVML_ERROR_NOT_FOUND if \a pciBusId does not match a valid device on the system * - \ref NVML_ERROR_INSUFFICIENT_POWER if the attached device has improperly attached external power cables * - \ref NVML_ERROR_NO_PERMISSION if the user doesn't have permission to talk to this device * - \ref NVML_ERROR_IRQ_ISSUE if NVIDIA kernel detected an interrupt issue with the attached GPUs * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetHandleByPciBusId(const char *pciBusId, nvmlDevice_t *device); /** * Retrieves the name of this device. * * For all products. * * The name is an alphanumeric string that denotes a particular product, e.g. Tesla &tm; C2070. It will not * exceed 64 characters in length (including the NULL terminator). See \ref * nvmlConstants::NVML_DEVICE_NAME_BUFFER_SIZE. * * @param device The identifier of the target device * @param name Reference in which to return the product name * @param length The maximum allowed length of the string returned in \a name * * @return * - \ref NVML_SUCCESS if \a name has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, or \a name is NULL * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetName(nvmlDevice_t device, char *name, unsigned int length); /** * Retrieves the brand of this device. * * For all products. * * The type is a member of \ref nvmlBrandType_t defined above. * * @param device The identifier of the target device * @param type Reference in which to return the product brand type * * @return * - \ref NVML_SUCCESS if \a name has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, or \a type is NULL * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetBrand(nvmlDevice_t device, nvmlBrandType_t *type); /** * Retrieves the NVML index of this device. * * For all products. * * Valid indices are derived from the \a accessibleDevices count returned by * \ref nvmlDeviceGetCount(). For example, if \a accessibleDevices is 2 the valid indices * are 0 and 1, corresponding to GPU 0 and GPU 1. * * The order in which NVML enumerates devices has no guarantees of consistency between reboots. For that reason it * is recommended that devices be looked up by their PCI ids or GPU UUID. See * \ref nvmlDeviceGetHandleByPciBusId() and \ref nvmlDeviceGetHandleByUUID(). * * Note: The NVML index may not correlate with other APIs, such as the CUDA device index. * * @param device The identifier of the target device * @param index Reference in which to return the NVML index of the device * * @return * - \ref NVML_SUCCESS if \a index has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, or \a index is NULL * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetHandleByIndex() * @see nvmlDeviceGetCount() */ nvmlReturn_t DECLDIR nvmlDeviceGetIndex(nvmlDevice_t device, unsigned int *index); /** * Retrieves the globally unique board serial number associated with this device's board. * * For all products with an inforom. * * The serial number is an alphanumeric string that will not exceed 30 characters (including the NULL terminator). * This number matches the serial number tag that is physically attached to the board. See \ref * nvmlConstants::NVML_DEVICE_SERIAL_BUFFER_SIZE. * * @param device The identifier of the target device * @param serial Reference in which to return the board/module serial number * @param length The maximum allowed length of the string returned in \a serial * * @return * - \ref NVML_SUCCESS if \a serial has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, or \a serial is NULL * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetSerial(nvmlDevice_t device, char *serial, unsigned int length); /** * Retrieves an array of unsigned ints (sized to cpuSetSize) of bitmasks with the ideal CPU affinity for the device * For example, if processors 0, 1, 32, and 33 are ideal for the device and cpuSetSize == 2, * result[0] = 0x3, result[1] = 0x3 * * For Kepler &tm; or newer fully supported devices. * Supported on Linux only. * * @param device The identifier of the target device * @param cpuSetSize The size of the cpuSet array that is safe to access * @param cpuSet Array reference in which to return a bitmask of CPUs, 64 CPUs per * unsigned long on 64-bit machines, 32 on 32-bit machines * * @return * - \ref NVML_SUCCESS if \a cpuAffinity has been filled * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, cpuSetSize == 0, or cpuSet is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetCpuAffinity(nvmlDevice_t device, unsigned int cpuSetSize, unsigned long *cpuSet); /** * Sets the ideal affinity for a device using the guidelines given in nvmlDeviceGetCpuAffinity() * Currently supports up to 64 processors. * * For Kepler &tm; or newer fully supported devices. * Supported on Linux only. * * @param device The identifier of the target device * * @return * - \ref NVML_SUCCESS if the calling process has been successfully bound * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceSetCpuAffinity(nvmlDevice_t device); /** * Clear all affinity bindings * * For Kepler &tm; or newer fully supported devices. * Supported on Linux only. * * @param device The identifier of the target device * * @return * - \ref NVML_SUCCESS if the calling process has been successfully unbound * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceClearCpuAffinity(nvmlDevice_t device); /** * Retrieves the globally unique immutable UUID associated with this device, as a 5 part hexadecimal string, * that augments the immutable, board serial identifier. * * For all products. * * The UUID is a globally unique identifier. It is the only available identifier for pre-Fermi-architecture products. * It does NOT correspond to any identifier printed on the board. It will not exceed 80 characters in length * (including the NULL terminator). See \ref nvmlConstants::NVML_DEVICE_UUID_BUFFER_SIZE. * * @param device The identifier of the target device * @param uuid Reference in which to return the GPU UUID * @param length The maximum allowed length of the string returned in \a uuid * * @return * - \ref NVML_SUCCESS if \a uuid has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, or \a uuid is NULL * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetUUID(nvmlDevice_t device, char *uuid, unsigned int length); /** * Retrieves minor number for the device. The minor number for the device is such that the Nvidia device node file for * each GPU will have the form /dev/nvidia[minor number]. * * For all products. * Supported only for Linux * * @param device The identifier of the target device * @param minorNumber Reference in which to return the minor number for the device * @return * - \ref NVML_SUCCESS if the minor number is successfully retrieved * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a minorNumber is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if this query is not supported by the device * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetMinorNumber(nvmlDevice_t device, unsigned int *minorNumber); /** * Retrieves the version information for the device's infoROM object. * * For all products with an inforom. * * Fermi and higher parts have non-volatile on-board memory for persisting device info, such as aggregate * ECC counts. The version of the data structures in this memory may change from time to time. It will not * exceed 16 characters in length (including the NULL terminator). * See \ref nvmlConstants::NVML_DEVICE_INFOROM_VERSION_BUFFER_SIZE. * * See \ref nvmlInforomObject_t for details on the available infoROM objects. * * @param device The identifier of the target device * @param object The target infoROM object * @param version Reference in which to return the infoROM version * @param length The maximum allowed length of the string returned in \a version * * @return * - \ref NVML_SUCCESS if \a version has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a version is NULL * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not have an infoROM * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetInforomImageVersion */ nvmlReturn_t DECLDIR nvmlDeviceGetInforomVersion(nvmlDevice_t device, nvmlInforomObject_t object, char *version, unsigned int length); /** * Retrieves the global infoROM image version * * For all products with an inforom. * * Image version just like VBIOS version uniquely describes the exact version of the infoROM flashed on the board * in contrast to infoROM object version which is only an indicator of supported features. * Version string will not exceed 16 characters in length (including the NULL terminator). * See \ref nvmlConstants::NVML_DEVICE_INFOROM_VERSION_BUFFER_SIZE. * * @param device The identifier of the target device * @param version Reference in which to return the infoROM image version * @param length The maximum allowed length of the string returned in \a version * * @return * - \ref NVML_SUCCESS if \a version has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a version is NULL * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not have an infoROM * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetInforomVersion */ nvmlReturn_t DECLDIR nvmlDeviceGetInforomImageVersion(nvmlDevice_t device, char *version, unsigned int length); /** * Retrieves the checksum of the configuration stored in the device's infoROM. * * For all products with an inforom. * * Can be used to make sure that two GPUs have the exact same configuration. * Current checksum takes into account configuration stored in PWR and ECC infoROM objects. * Checksum can change between driver releases or when user changes configuration (e.g. disable/enable ECC) * * @param device The identifier of the target device * @param checksum Reference in which to return the infoROM configuration checksum * * @return * - \ref NVML_SUCCESS if \a checksum has been set * - \ref NVML_ERROR_CORRUPTED_INFOROM if the device's checksum couldn't be retrieved due to infoROM corruption * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a checksum is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetInforomConfigurationChecksum(nvmlDevice_t device, unsigned int *checksum); /** * Reads the infoROM from the flash and verifies the checksums. * * For all products with an inforom. * * @param device The identifier of the target device * * @return * - \ref NVML_SUCCESS if infoROM is not corrupted * - \ref NVML_ERROR_CORRUPTED_INFOROM if the device's infoROM is corrupted * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceValidateInforom(nvmlDevice_t device); /** * Retrieves the display mode for the device. * * For all products. * * This method indicates whether a physical display (e.g. monitor) is currently connected to * any of the device's connectors. * * See \ref nvmlEnableState_t for details on allowed modes. * * @param device The identifier of the target device * @param display Reference in which to return the display mode * * @return * - \ref NVML_SUCCESS if \a display has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a display is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetDisplayMode(nvmlDevice_t device, nvmlEnableState_t *display); /** * Retrieves the display active state for the device. * * For all products. * * This method indicates whether a display is initialized on the device. * For example whether X Server is attached to this device and has allocated memory for the screen. * * Display can be active even when no monitor is physically attached. * * See \ref nvmlEnableState_t for details on allowed modes. * * @param device The identifier of the target device * @param isActive Reference in which to return the display active state * * @return * - \ref NVML_SUCCESS if \a isActive has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a isActive is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetDisplayActive(nvmlDevice_t device, nvmlEnableState_t *isActive); /** * Retrieves the persistence mode associated with this device. * * For all products. * For Linux only. * * When driver persistence mode is enabled the driver software state is not torn down when the last * client disconnects. By default this feature is disabled. * * See \ref nvmlEnableState_t for details on allowed modes. * * @param device The identifier of the target device * @param mode Reference in which to return the current driver persistence mode * * @return * - \ref NVML_SUCCESS if \a mode has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a mode is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceSetPersistenceMode() */ nvmlReturn_t DECLDIR nvmlDeviceGetPersistenceMode(nvmlDevice_t device, nvmlEnableState_t *mode); /** * Retrieves the PCI attributes of this device. * * For all products. * * See \ref nvmlPciInfo_t for details on the available PCI info. * * @param device The identifier of the target device * @param pci Reference in which to return the PCI info * * @return * - \ref NVML_SUCCESS if \a pci has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a pci is NULL * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetPciInfo(nvmlDevice_t device, nvmlPciInfo_t *pci); /** * Retrieves the maximum PCIe link generation possible with this device and system * * I.E. for a generation 2 PCIe device attached to a generation 1 PCIe bus the max link generation this function will * report is generation 1. * * For Fermi &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param maxLinkGen Reference in which to return the max PCIe link generation * * @return * - \ref NVML_SUCCESS if \a maxLinkGen has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a maxLinkGen is null * - \ref NVML_ERROR_NOT_SUPPORTED if PCIe link information is not available * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetMaxPcieLinkGeneration(nvmlDevice_t device, unsigned int *maxLinkGen); /** * Retrieves the maximum PCIe link width possible with this device and system * * I.E. for a device with a 16x PCIe bus width attached to a 8x PCIe system bus this function will report * a max link width of 8. * * For Fermi &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param maxLinkWidth Reference in which to return the max PCIe link generation * * @return * - \ref NVML_SUCCESS if \a maxLinkWidth has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a maxLinkWidth is null * - \ref NVML_ERROR_NOT_SUPPORTED if PCIe link information is not available * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetMaxPcieLinkWidth(nvmlDevice_t device, unsigned int *maxLinkWidth); /** * Retrieves the current PCIe link generation * * For Fermi &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param currLinkGen Reference in which to return the current PCIe link generation * * @return * - \ref NVML_SUCCESS if \a currLinkGen has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a currLinkGen is null * - \ref NVML_ERROR_NOT_SUPPORTED if PCIe link information is not available * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetCurrPcieLinkGeneration(nvmlDevice_t device, unsigned int *currLinkGen); /** * Retrieves the current PCIe link width * * For Fermi &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param currLinkWidth Reference in which to return the current PCIe link generation * * @return * - \ref NVML_SUCCESS if \a currLinkWidth has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a currLinkWidth is null * - \ref NVML_ERROR_NOT_SUPPORTED if PCIe link information is not available * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetCurrPcieLinkWidth(nvmlDevice_t device, unsigned int *currLinkWidth); /** * Retrieve PCIe utilization information. * This function is querying a byte counter over a 20ms interval and thus is the * PCIe throughput over that interval. * * For Maxwell &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param counter The specific counter that should be queried \ref nvmlPcieUtilCounter_t * @param value Reference in which to return throughput in KB/s * * @return * - \ref NVML_SUCCESS if \a value has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device or \a counter is invalid, or \a value is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetPcieThroughput(nvmlDevice_t device, nvmlPcieUtilCounter_t counter, unsigned int *value); /** * Retrieve the PCIe replay counter and rollover information * * For Kepler &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param value Reference in which to return the counter's value * * @return * - \ref NVML_SUCCESS if \a value and \a rollover have been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, or \a value or \a rollover are NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetPcieReplayCounter(nvmlDevice_t device, unsigned int *value); /** * Retrieves the current clock speeds for the device. * * For Fermi &tm; or newer fully supported devices. * * See \ref nvmlClockType_t for details on available clock information. * * @param device The identifier of the target device * @param type Identify which clock domain to query * @param clock Reference in which to return the clock speed in MHz * * @return * - \ref NVML_SUCCESS if \a clock has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a clock is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device cannot report the specified clock * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetClockInfo(nvmlDevice_t device, nvmlClockType_t type, unsigned int *clock); /** * Retrieves the maximum clock speeds for the device. * * For Fermi &tm; or newer fully supported devices. * * See \ref nvmlClockType_t for details on available clock information. * * \note On GPUs from Fermi family current P0 clocks (reported by \ref nvmlDeviceGetClockInfo) can differ from max clocks * by few MHz. * * @param device The identifier of the target device * @param type Identify which clock domain to query * @param clock Reference in which to return the clock speed in MHz * * @return * - \ref NVML_SUCCESS if \a clock has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a clock is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device cannot report the specified clock * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetMaxClockInfo(nvmlDevice_t device, nvmlClockType_t type, unsigned int *clock); /** * Retrieves the current setting of a clock that applications will use unless an overspec situation occurs. * Can be changed using \ref nvmlDeviceSetApplicationsClocks. * * For Kepler &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param clockType Identify which clock domain to query * @param clockMHz Reference in which to return the clock in MHz * * @return * - \ref NVML_SUCCESS if \a clockMHz has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a clockMHz is NULL or \a clockType is invalid * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetApplicationsClock(nvmlDevice_t device, nvmlClockType_t clockType, unsigned int *clockMHz); /** * Retrieves the default applications clock that GPU boots with or * defaults to after \ref nvmlDeviceResetApplicationsClocks call. * * For Kepler &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param clockType Identify which clock domain to query * @param clockMHz Reference in which to return the default clock in MHz * * @return * - \ref NVML_SUCCESS if \a clockMHz has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a clockMHz is NULL or \a clockType is invalid * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * \see nvmlDeviceGetApplicationsClock */ nvmlReturn_t DECLDIR nvmlDeviceGetDefaultApplicationsClock(nvmlDevice_t device, nvmlClockType_t clockType, unsigned int *clockMHz); /** * Resets the application clock to the default value * * This is the applications clock that will be used after system reboot or driver reload. * Default value is constant, but the current value an be changed using \ref nvmlDeviceSetApplicationsClocks. * * @see nvmlDeviceGetApplicationsClock * @see nvmlDeviceSetApplicationsClocks * * For Fermi &tm; or newer non-GeForce fully supported devices and Maxwell or newer GeForce devices. * * @param device The identifier of the target device * * @return * - \ref NVML_SUCCESS if new settings were successfully set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceResetApplicationsClocks(nvmlDevice_t device); /** * Retrieves the list of possible memory clocks that can be used as an argument for \ref nvmlDeviceSetApplicationsClocks. * * For Kepler &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param count Reference in which to provide the \a clocksMHz array size, and * to return the number of elements * @param clocksMHz Reference in which to return the clock in MHz * * @return * - \ref NVML_SUCCESS if \a count and \a clocksMHz have been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a count is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a count is too small (\a count is set to the number of * required elements) * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceSetApplicationsClocks * @see nvmlDeviceGetSupportedGraphicsClocks */ nvmlReturn_t DECLDIR nvmlDeviceGetSupportedMemoryClocks(nvmlDevice_t device, unsigned int *count, unsigned int *clocksMHz); /** * Retrieves the list of possible graphics clocks that can be used as an argument for \ref nvmlDeviceSetApplicationsClocks. * * For Kepler &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param memoryClockMHz Memory clock for which to return possible graphics clocks * @param count Reference in which to provide the \a clocksMHz array size, and * to return the number of elements * @param clocksMHz Reference in which to return the clocks in MHz * * @return * - \ref NVML_SUCCESS if \a count and \a clocksMHz have been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_NOT_FOUND if the specified \a memoryClockMHz is not a supported frequency * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a clock is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a count is too small * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceSetApplicationsClocks * @see nvmlDeviceGetSupportedMemoryClocks */ nvmlReturn_t DECLDIR nvmlDeviceGetSupportedGraphicsClocks(nvmlDevice_t device, unsigned int memoryClockMHz, unsigned int *count, unsigned int *clocksMHz); /** * Retrieve the current state of auto boosted clocks on a device and store it in \a isEnabled * * For Kepler &tm; or newer fully supported devices. * * Auto boosted clocks are enabled by default on some hardware, allowing the GPU to run at higher clock rates * to maximize performance as thermal limits allow. * * @param device The identifier of the target device * @param isEnabled Where to store the current state of auto boosted clocks of the target device * @param defaultIsEnabled Where to store the default auto boosted clocks behavior of the target device that the device will * revert to when no applications are using the GPU * * @return * - \ref NVML_SUCCESS If \a isEnabled has been been set with the auto boosted clocks state of \a device * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a isEnabled is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support auto boosted clocks * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * */ nvmlReturn_t DECLDIR nvmlDeviceGetAutoBoostedClocksEnabled(nvmlDevice_t device, nvmlEnableState_t *isEnabled, nvmlEnableState_t *defaultIsEnabled); /** * Try to set the current state of auto boosted clocks on a device. * * For Kepler &tm; or newer fully supported devices. * * Auto boosted clocks are enabled by default on some hardware, allowing the GPU to run at higher clock rates * to maximize performance as thermal limits allow. Auto boosted clocks should be disabled if fixed clock * rates are desired. * Non-root users may use this API by default but can be restricted by root from using this API by calling * \ref nvmlDeviceSetAPIRestriction with apiType=NVML_RESTRICTED_API_SET_AUTO_BOOSTED_CLOCKS. * * @param device The identifier of the target device * @param enabled What state to try to set auto boosted clocks of the target device to * * @return * - \ref NVML_SUCCESS If the auto boosted clocks were successfully set to the state specified by \a enabled * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support auto boosted clocks * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * */ nvmlReturn_t DECLDIR nvmlDeviceSetAutoBoostedClocksEnabled(nvmlDevice_t device, nvmlEnableState_t enabled); /** * Try to set the default state of auto boosted clocks on a device. This is the default state that auto boosted clocks will * return to when no compute running processes (e.g. CUDA application which have an active context) are running * * For Kepler &tm; or newer non-GeForce fully supported devices and Maxwell or newer GeForce devices. * Requires root/admin permissions. * * Auto boosted clocks are enabled by default on some hardware, allowing the GPU to run at higher clock rates * to maximize performance as thermal limits allow. Auto boosted clocks should be disabled if fixed clock * rates are desired. * * @param device The identifier of the target device * @param enabled What state to try to set default auto boosted clocks of the target device to * @param flags Flags that change the default behavior. Currently Unused. * * @return * - \ref NVML_SUCCESS If the auto boosted clock's default state was successfully set to the state specified by \a enabled * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_NO_PERMISSION If the calling user does not have permission to change auto boosted clock's default state. * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support auto boosted clocks * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * */ nvmlReturn_t DECLDIR nvmlDeviceSetDefaultAutoBoostedClocksEnabled(nvmlDevice_t device, nvmlEnableState_t enabled, unsigned int flags); /** * Retrieves the intended operating speed of the device's fan. * * Note: The reported speed is the intended fan speed. If the fan is physically blocked and unable to spin, the * output will not match the actual fan speed. * * For all discrete products with dedicated fans. * * The fan speed is expressed as a percent of the maximum, i.e. full speed is 100%. * * @param device The identifier of the target device * @param speed Reference in which to return the fan speed percentage * * @return * - \ref NVML_SUCCESS if \a speed has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a speed is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not have a fan * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetFanSpeed(nvmlDevice_t device, unsigned int *speed); /** * Retrieves the current temperature readings for the device, in degrees C. * * For all products. * * See \ref nvmlTemperatureSensors_t for details on available temperature sensors. * * @param device The identifier of the target device * @param sensorType Flag that indicates which sensor reading to retrieve * @param temp Reference in which to return the temperature reading * * @return * - \ref NVML_SUCCESS if \a temp has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, \a sensorType is invalid or \a temp is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not have the specified sensor * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetTemperature(nvmlDevice_t device, nvmlTemperatureSensors_t sensorType, unsigned int *temp); /** * Retrieves the temperature threshold for the GPU with the specified threshold type in degrees C. * * For Kepler &tm; or newer fully supported devices. * * See \ref nvmlTemperatureThresholds_t for details on available temperature thresholds. * * @param device The identifier of the target device * @param thresholdType The type of threshold value queried * @param temp Reference in which to return the temperature reading * @return * - \ref NVML_SUCCESS if \a temp has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, \a thresholdType is invalid or \a temp is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not have a temperature sensor or is unsupported * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetTemperatureThreshold(nvmlDevice_t device, nvmlTemperatureThresholds_t thresholdType, unsigned int *temp); /** * Retrieves the current performance state for the device. * * For Fermi &tm; or newer fully supported devices. * * See \ref nvmlPstates_t for details on allowed performance states. * * @param device The identifier of the target device * @param pState Reference in which to return the performance state reading * * @return * - \ref NVML_SUCCESS if \a pState has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a pState is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetPerformanceState(nvmlDevice_t device, nvmlPstates_t *pState); /** * Retrieves current clocks throttling reasons. * * For all fully supported products. * * \note More than one bit can be enabled at the same time. Multiple reasons can be affecting clocks at once. * * @param device The identifier of the target device * @param clocksThrottleReasons Reference in which to return bitmask of active clocks throttle * reasons * * @return * - \ref NVML_SUCCESS if \a clocksThrottleReasons has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a clocksThrottleReasons is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlClocksThrottleReasons * @see nvmlDeviceGetSupportedClocksThrottleReasons */ nvmlReturn_t DECLDIR nvmlDeviceGetCurrentClocksThrottleReasons(nvmlDevice_t device, unsigned long long *clocksThrottleReasons); /** * Retrieves bitmask of supported clocks throttle reasons that can be returned by * \ref nvmlDeviceGetCurrentClocksThrottleReasons * * For all fully supported products. * * @param device The identifier of the target device * @param supportedClocksThrottleReasons Reference in which to return bitmask of supported * clocks throttle reasons * * @return * - \ref NVML_SUCCESS if \a supportedClocksThrottleReasons has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a supportedClocksThrottleReasons is NULL * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlClocksThrottleReasons * @see nvmlDeviceGetCurrentClocksThrottleReasons */ nvmlReturn_t DECLDIR nvmlDeviceGetSupportedClocksThrottleReasons(nvmlDevice_t device, unsigned long long *supportedClocksThrottleReasons); /** * Deprecated: Use \ref nvmlDeviceGetPerformanceState. This function exposes an incorrect generalization. * * Retrieve the current performance state for the device. * * For Fermi &tm; or newer fully supported devices. * * See \ref nvmlPstates_t for details on allowed performance states. * * @param device The identifier of the target device * @param pState Reference in which to return the performance state reading * * @return * - \ref NVML_SUCCESS if \a pState has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a pState is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetPowerState(nvmlDevice_t device, nvmlPstates_t *pState); /** * This API has been deprecated. * * Retrieves the power management mode associated with this device. * * For products from the Fermi family. * - Requires \a NVML_INFOROM_POWER version 3.0 or higher. * * For from the Kepler or newer families. * - Does not require \a NVML_INFOROM_POWER object. * * This flag indicates whether any power management algorithm is currently active on the device. An * enabled state does not necessarily mean the device is being actively throttled -- only that * that the driver will do so if the appropriate conditions are met. * * See \ref nvmlEnableState_t for details on allowed modes. * * @param device The identifier of the target device * @param mode Reference in which to return the current power management mode * * @return * - \ref NVML_SUCCESS if \a mode has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a mode is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetPowerManagementMode(nvmlDevice_t device, nvmlEnableState_t *mode); /** * Retrieves the power management limit associated with this device. * * For Fermi &tm; or newer fully supported devices. * * The power limit defines the upper boundary for the card's power draw. If * the card's total power draw reaches this limit the power management algorithm kicks in. * * This reading is only available if power management mode is supported. * See \ref nvmlDeviceGetPowerManagementMode. * * @param device The identifier of the target device * @param limit Reference in which to return the power management limit in milliwatts * * @return * - \ref NVML_SUCCESS if \a limit has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a limit is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetPowerManagementLimit(nvmlDevice_t device, unsigned int *limit); /** * Retrieves information about possible values of power management limits on this device. * * For Kepler &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param minLimit Reference in which to return the minimum power management limit in milliwatts * @param maxLimit Reference in which to return the maximum power management limit in milliwatts * * @return * - \ref NVML_SUCCESS if \a minLimit and \a maxLimit have been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a minLimit or \a maxLimit is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceSetPowerManagementLimit */ nvmlReturn_t DECLDIR nvmlDeviceGetPowerManagementLimitConstraints(nvmlDevice_t device, unsigned int *minLimit, unsigned int *maxLimit); /** * Retrieves default power management limit on this device, in milliwatts. * Default power management limit is a power management limit that the device boots with. * * For Kepler &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param defaultLimit Reference in which to return the default power management limit in milliwatts * * @return * - \ref NVML_SUCCESS if \a defaultLimit has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a defaultLimit is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetPowerManagementDefaultLimit(nvmlDevice_t device, unsigned int *defaultLimit); /** * Retrieves power usage for this GPU in milliwatts and its associated circuitry (e.g. memory) * * For Fermi &tm; or newer fully supported devices. * * On Fermi and Kepler GPUs the reading is accurate to within +/- 5% of current power draw. * * It is only available if power management mode is supported. See \ref nvmlDeviceGetPowerManagementMode. * * @param device The identifier of the target device * @param power Reference in which to return the power usage information * * @return * - \ref NVML_SUCCESS if \a power has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a power is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support power readings * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetPowerUsage(nvmlDevice_t device, unsigned int *power); /** * Get the effective power limit that the driver enforces after taking into account all limiters * * Note: This can be different from the \ref nvmlDeviceGetPowerManagementLimit if other limits are set elsewhere * This includes the out of band power limit interface * * For Kepler &tm; or newer fully supported devices. * * @param device The device to communicate with * @param limit Reference in which to return the power management limit in milliwatts * * @return * - \ref NVML_SUCCESS if \a limit has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a limit is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetEnforcedPowerLimit(nvmlDevice_t device, unsigned int *limit); /** * Retrieves the current GOM and pending GOM (the one that GPU will switch to after reboot). * * For GK110 M-class and X-class Tesla &tm; products from the Kepler family. * Modes \ref NVML_GOM_LOW_DP and \ref NVML_GOM_ALL_ON are supported on fully supported GeForce products. * Not supported on Quadro ® and Tesla &tm; C-class products. * * @param device The identifier of the target device * @param current Reference in which to return the current GOM * @param pending Reference in which to return the pending GOM * * @return * - \ref NVML_SUCCESS if \a mode has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a current or \a pending is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlGpuOperationMode_t * @see nvmlDeviceSetGpuOperationMode */ nvmlReturn_t DECLDIR nvmlDeviceGetGpuOperationMode(nvmlDevice_t device, nvmlGpuOperationMode_t *current, nvmlGpuOperationMode_t *pending); /** * Retrieves the amount of used, free and total memory available on the device, in bytes. * * For all products. * * Enabling ECC reduces the amount of total available memory, due to the extra required parity bits. * Under WDDM most device memory is allocated and managed on startup by Windows. * * Under Linux and Windows TCC, the reported amount of used memory is equal to the sum of memory allocated * by all active channels on the device. * * See \ref nvmlMemory_t for details on available memory info. * * @param device The identifier of the target device * @param memory Reference in which to return the memory information * * @return * - \ref NVML_SUCCESS if \a memory has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a memory is NULL * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetMemoryInfo(nvmlDevice_t device, nvmlMemory_t *memory); /** * Retrieves the current compute mode for the device. * * For all products. * * See \ref nvmlComputeMode_t for details on allowed compute modes. * * @param device The identifier of the target device * @param mode Reference in which to return the current compute mode * * @return * - \ref NVML_SUCCESS if \a mode has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a mode is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceSetComputeMode() */ nvmlReturn_t DECLDIR nvmlDeviceGetComputeMode(nvmlDevice_t device, nvmlComputeMode_t *mode); /** * Retrieves the current and pending ECC modes for the device. * * For Fermi &tm; or newer fully supported devices. * Only applicable to devices with ECC. * Requires \a NVML_INFOROM_ECC version 1.0 or higher. * * Changing ECC modes requires a reboot. The "pending" ECC mode refers to the target mode following * the next reboot. * * See \ref nvmlEnableState_t for details on allowed modes. * * @param device The identifier of the target device * @param current Reference in which to return the current ECC mode * @param pending Reference in which to return the pending ECC mode * * @return * - \ref NVML_SUCCESS if \a current and \a pending have been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or either \a current or \a pending is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceSetEccMode() */ nvmlReturn_t DECLDIR nvmlDeviceGetEccMode(nvmlDevice_t device, nvmlEnableState_t *current, nvmlEnableState_t *pending); /** * Retrieves the device boardId from 0-N. * Devices with the same boardId indicate GPUs connected to the same PLX. Use in conjunction with * \ref nvmlDeviceGetMultiGpuBoard() to decide if they are on the same board as well. * The boardId returned is a unique ID for the current configuration. Uniqueness and ordering across * reboots and system configurations is not guaranteed (i.e. if a Tesla K40c returns 0x100 and * the two GPUs on a Tesla K10 in the same system returns 0x200 it is not guaranteed they will * always return those values but they will always be different from each other). * * * For Fermi &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param boardId Reference in which to return the device's board ID * * @return * - \ref NVML_SUCCESS if \a boardId has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a boardId is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetBoardId(nvmlDevice_t device, unsigned int *boardId); /** * Retrieves whether the device is on a Multi-GPU Board * Devices that are on multi-GPU boards will set \a multiGpuBool to a non-zero value. * * For Fermi &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param multiGpuBool Reference in which to return a zero or non-zero value * to indicate whether the device is on a multi GPU board * * @return * - \ref NVML_SUCCESS if \a multiGpuBool has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a multiGpuBool is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetMultiGpuBoard(nvmlDevice_t device, unsigned int *multiGpuBool); /** * Retrieves the total ECC error counts for the device. * * For Fermi &tm; or newer fully supported devices. * Only applicable to devices with ECC. * Requires \a NVML_INFOROM_ECC version 1.0 or higher. * Requires ECC Mode to be enabled. * * The total error count is the sum of errors across each of the separate memory systems, i.e. the total set of * errors across the entire device. * * See \ref nvmlMemoryErrorType_t for a description of available error types.\n * See \ref nvmlEccCounterType_t for a description of available counter types. * * @param device The identifier of the target device * @param errorType Flag that specifies the type of the errors. * @param counterType Flag that specifies the counter-type of the errors. * @param eccCounts Reference in which to return the specified ECC errors * * @return * - \ref NVML_SUCCESS if \a eccCounts has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device, \a errorType or \a counterType is invalid, or \a eccCounts is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceClearEccErrorCounts() */ nvmlReturn_t DECLDIR nvmlDeviceGetTotalEccErrors(nvmlDevice_t device, nvmlMemoryErrorType_t errorType, nvmlEccCounterType_t counterType, unsigned long long *eccCounts); /** * Retrieves the detailed ECC error counts for the device. * * @deprecated This API supports only a fixed set of ECC error locations * On different GPU architectures different locations are supported * See \ref nvmlDeviceGetMemoryErrorCounter * * For Fermi &tm; or newer fully supported devices. * Only applicable to devices with ECC. * Requires \a NVML_INFOROM_ECC version 2.0 or higher to report aggregate location-based ECC counts. * Requires \a NVML_INFOROM_ECC version 1.0 or higher to report all other ECC counts. * Requires ECC Mode to be enabled. * * Detailed errors provide separate ECC counts for specific parts of the memory system. * * Reports zero for unsupported ECC error counters when a subset of ECC error counters are supported. * * See \ref nvmlMemoryErrorType_t for a description of available bit types.\n * See \ref nvmlEccCounterType_t for a description of available counter types.\n * See \ref nvmlEccErrorCounts_t for a description of provided detailed ECC counts. * * @param device The identifier of the target device * @param errorType Flag that specifies the type of the errors. * @param counterType Flag that specifies the counter-type of the errors. * @param eccCounts Reference in which to return the specified ECC errors * * @return * - \ref NVML_SUCCESS if \a eccCounts has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device, \a errorType or \a counterType is invalid, or \a eccCounts is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceClearEccErrorCounts() */ nvmlReturn_t DECLDIR nvmlDeviceGetDetailedEccErrors(nvmlDevice_t device, nvmlMemoryErrorType_t errorType, nvmlEccCounterType_t counterType, nvmlEccErrorCounts_t *eccCounts); /** * Retrieves the requested memory error counter for the device. * * For Fermi &tm; or newer fully supported devices. * Requires \a NVML_INFOROM_ECC version 2.0 or higher to report aggregate location-based memory error counts. * Requires \a NVML_INFOROM_ECC version 1.0 or higher to report all other memory error counts. * * Only applicable to devices with ECC. * * Requires ECC Mode to be enabled. * * See \ref nvmlMemoryErrorType_t for a description of available memory error types.\n * See \ref nvmlEccCounterType_t for a description of available counter types.\n * See \ref nvmlMemoryLocation_t for a description of available counter locations.\n * * @param device The identifier of the target device * @param errorType Flag that specifies the type of error. * @param counterType Flag that specifies the counter-type of the errors. * @param locationType Specifies the location of the counter. * @param count Reference in which to return the ECC counter * * @return * - \ref NVML_SUCCESS if \a count has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device, \a bitTyp,e \a counterType or \a locationType is * invalid, or \a count is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support ECC error reporting in the specified memory * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetMemoryErrorCounter(nvmlDevice_t device, nvmlMemoryErrorType_t errorType, nvmlEccCounterType_t counterType, nvmlMemoryLocation_t locationType, unsigned long long *count); /** * Retrieves the current utilization rates for the device's major subsystems. * * For Fermi &tm; or newer fully supported devices. * * See \ref nvmlUtilization_t for details on available utilization rates. * * \note During driver initialization when ECC is enabled one can see high GPU and Memory Utilization readings. * This is caused by ECC Memory Scrubbing mechanism that is performed during driver initialization. * * @param device The identifier of the target device * @param utilization Reference in which to return the utilization information * * @return * - \ref NVML_SUCCESS if \a utilization has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a utilization is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetUtilizationRates(nvmlDevice_t device, nvmlUtilization_t *utilization); /** * Retrieves the current utilization and sampling size in microseconds for the Encoder * * For Kepler &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param utilization Reference to an unsigned int for encoder utilization info * @param samplingPeriodUs Reference to an unsigned int for the sampling period in US * * @return * - \ref NVML_SUCCESS if \a utilization has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, \a utilization is NULL, or \a samplingPeriodUs is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetEncoderUtilization(nvmlDevice_t device, unsigned int *utilization, unsigned int *samplingPeriodUs); /** * Retrieves the current utilization and sampling size in microseconds for the Decoder * * For Kepler &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param utilization Reference to an unsigned int for decoder utilization info * @param samplingPeriodUs Reference to an unsigned int for the sampling period in US * * @return * - \ref NVML_SUCCESS if \a utilization has been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, \a utilization is NULL, or \a samplingPeriodUs is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetDecoderUtilization(nvmlDevice_t device, unsigned int *utilization, unsigned int *samplingPeriodUs); /** * Retrieves the current and pending driver model for the device. * * For Fermi &tm; or newer fully supported devices. * For windows only. * * On Windows platforms the device driver can run in either WDDM or WDM (TCC) mode. If a display is attached * to the device it must run in WDDM mode. TCC mode is preferred if a display is not attached. * * See \ref nvmlDriverModel_t for details on available driver models. * * @param device The identifier of the target device * @param current Reference in which to return the current driver model * @param pending Reference in which to return the pending driver model * * @return * - \ref NVML_SUCCESS if either \a current and/or \a pending have been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or both \a current and \a pending are NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the platform is not windows * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceSetDriverModel() */ nvmlReturn_t DECLDIR nvmlDeviceGetDriverModel(nvmlDevice_t device, nvmlDriverModel_t *current, nvmlDriverModel_t *pending); /** * Get VBIOS version of the device. * * For all products. * * The VBIOS version may change from time to time. It will not exceed 32 characters in length * (including the NULL terminator). See \ref nvmlConstants::NVML_DEVICE_VBIOS_VERSION_BUFFER_SIZE. * * @param device The identifier of the target device * @param version Reference to which to return the VBIOS version * @param length The maximum allowed length of the string returned in \a version * * @return * - \ref NVML_SUCCESS if \a version has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, or \a version is NULL * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetVbiosVersion(nvmlDevice_t device, char *version, unsigned int length); /** * Get Bridge Chip Information for all the bridge chips on the board. * * For all fully supported products. * Only applicable to multi-GPU products. * * @param device The identifier of the target device * @param bridgeHierarchy Reference to the returned bridge chip Hierarchy * * @return * - \ref NVML_SUCCESS if bridge chip exists * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, or \a bridgeInfo is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if bridge chip not supported on the device * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * */ nvmlReturn_t DECLDIR nvmlDeviceGetBridgeChipInfo(nvmlDevice_t device, nvmlBridgeChipHierarchy_t *bridgeHierarchy); /** * Get information about processes with a compute context on a device * * For Kepler &tm; or newer fully supported devices. * * This function returns information only about compute running processes (e.g. CUDA application which have * active context). Any graphics applications (e.g. using OpenGL, DirectX) won't be listed by this function. * * To query the current number of running compute processes, call this function with *infoCount = 0. The * return code will be NVML_ERROR_INSUFFICIENT_SIZE, or NVML_SUCCESS if none are running. For this call * \a infos is allowed to be NULL. * * Keep in mind that information returned by this call is dynamic and the number of elements might change in * time. Allocate more space for \a infos table in case new compute processes are spawned. * * @param device The identifier of the target device * @param infoCount Reference in which to provide the \a infos array size, and * to return the number of returned elements * @param infos Reference in which to return the process information * * @return * - \ref NVML_SUCCESS if \a infoCount and \a infos have been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a infoCount indicates that the \a infos array is too small * \a infoCount will contain minimal amount of space necessary for * the call to complete * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, either of \a infoCount or \a infos is NULL * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see \ref nvmlSystemGetProcessName */ nvmlReturn_t DECLDIR nvmlDeviceGetComputeRunningProcesses(nvmlDevice_t device, unsigned int *infoCount, nvmlProcessInfo_t *infos); /** * Get information about processes with a graphics context on a device * * For Kepler &tm; or newer fully supported devices. * * This function returns information only about graphics based processes * (eg. applications using OpenGL, DirectX) * * To query the current number of running graphics processes, call this function with *infoCount = 0. The * return code will be NVML_ERROR_INSUFFICIENT_SIZE, or NVML_SUCCESS if none are running. For this call * \a infos is allowed to be NULL. * * Keep in mind that information returned by this call is dynamic and the number of elements might change in * time. Allocate more space for \a infos table in case new graphics processes are spawned. * * @param device The identifier of the target device * @param infoCount Reference in which to provide the \a infos array size, and * to return the number of returned elements * @param infos Reference in which to return the process information * * @return * - \ref NVML_SUCCESS if \a infoCount and \a infos have been populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a infoCount indicates that the \a infos array is too small * \a infoCount will contain minimal amount of space necessary for * the call to complete * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, either of \a infoCount or \a infos is NULL * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see \ref nvmlSystemGetProcessName */ nvmlReturn_t DECLDIR nvmlDeviceGetGraphicsRunningProcesses(nvmlDevice_t device, unsigned int *infoCount, nvmlProcessInfo_t *infos); /** * Check if the GPU devices are on the same physical board. * * For all fully supported products. * * @param device1 The first GPU device * @param device2 The second GPU device * @param onSameBoard Reference in which to return the status. * Non-zero indicates that the GPUs are on the same board. * * @return * - \ref NVML_SUCCESS if \a onSameBoard has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a dev1 or \a dev2 are invalid or \a onSameBoard is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if this check is not supported by the device * - \ref NVML_ERROR_GPU_IS_LOST if the either GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceOnSameBoard(nvmlDevice_t device1, nvmlDevice_t device2, int *onSameBoard); /** * Retrieves the root/admin permissions on the target API. See \a nvmlRestrictedAPI_t for the list of supported APIs. * If an API is restricted only root users can call that API. See \a nvmlDeviceSetAPIRestriction to change current permissions. * * For all fully supported products. * * @param device The identifier of the target device * @param apiType Target API type for this operation * @param isRestricted Reference in which to return the current restriction * NVML_FEATURE_ENABLED indicates that the API is root-only * NVML_FEATURE_DISABLED indicates that the API is accessible to all users * * @return * - \ref NVML_SUCCESS if \a isRestricted has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, \a apiType incorrect or \a isRestricted is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if this query is not supported by the device or the device does not support * the feature that is being queried (E.G. Enabling/disabling auto boosted clocks is * not supported by the device) * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlRestrictedAPI_t */ nvmlReturn_t DECLDIR nvmlDeviceGetAPIRestriction(nvmlDevice_t device, nvmlRestrictedAPI_t apiType, nvmlEnableState_t *isRestricted); /** * Gets recent samples for the GPU. * * For all fully supported products. * * Based on type, this method can be used to fetch the power, utilization or clock samples maintained in the buffer by * the driver. * * Power, Utilization and Clock samples are returned as type "unsigned int" for the union nvmlValue_t. * * To get the size of samples that user needs to allocate, the method is invoked with samples set to NULL. * The returned samplesCount will provide the number of samples that can be queried. The user needs to * allocate the buffer with size as samplesCount * sizeof(nvmlSample_t). * * lastSeenTimeStamp represents CPU timestamp in microseconds. Set it to 0 to fetch all the samples maintained by the * underlying buffer. Set lastSeenTimeStamp to one of the timeStamps retrieved from the date of the previous query * to get more recent samples. * * This method fetches the number of entries which can be accommodated in the provided samples array, and the * reference samplesCount is updated to indicate how many samples were actually retrieved. The advantage of using this * method for samples in contrast to polling via existing methods is to get get higher frequency data at lower polling cost. * * @param device The identifier for the target device * @param type Type of sampling event * @param lastSeenTimeStamp Return only samples with timestamp greater than lastSeenTimeStamp. * @param sampleValType Output parameter to represent the type of sample value as described in nvmlSampleVal_t * @param sampleCount Reference to provide the number of elements which can be queried in samples array * @param samples Reference in which samples are returned * @return * - \ref NVML_SUCCESS if samples are successfully retrieved * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, \a samplesCount is NULL or * reference to \a sampleCount is 0 for non null \a samples * - \ref NVML_ERROR_NOT_SUPPORTED if this query is not supported by the device * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_NOT_FOUND if sample entries are not found * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetSamples(nvmlDevice_t device, nvmlSamplingType_t type, unsigned long long lastSeenTimeStamp, nvmlValueType_t *sampleValType, unsigned int *sampleCount, nvmlSample_t *samples); /** * Gets Total, Available and Used size of BAR1 memory. * * BAR1 is used to map the FB (device memory) so that it can be directly accessed by the CPU or by 3rd party * devices (peer-to-peer on the PCIE bus). * * For Kepler &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param bar1Memory Reference in which BAR1 memory * information is returned. * * @return * - \ref NVML_SUCCESS if BAR1 memory is successfully retrieved * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, \a bar1Memory is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if this query is not supported by the device * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * */ nvmlReturn_t DECLDIR nvmlDeviceGetBAR1MemoryInfo(nvmlDevice_t device, nvmlBAR1Memory_t *bar1Memory); /** * Gets the duration of time during which the device was throttled (lower than requested clocks) due to power * or thermal constraints. * * The method is important to users who are tying to understand if their GPUs throttle at any point during their applications. The * difference in violation times at two different reference times gives the indication of GPU throttling event. * * Violation for thermal capping is not supported at this time. * * For Kepler &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param perfPolicyType Represents Performance policy which can trigger GPU throttling * @param violTime Reference to which violation time related information is returned * * * @return * - \ref NVML_SUCCESS if violation time is successfully retrieved * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, \a perfPolicyType is invalid, or \a violTime is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if this query is not supported by the device * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * */ nvmlReturn_t DECLDIR nvmlDeviceGetViolationStatus(nvmlDevice_t device, nvmlPerfPolicyType_t perfPolicyType, nvmlViolationTime_t *violTime); /** * @} */ /** @addtogroup nvmlAccountingStats * @{ */ /** * Queries the state of per process accounting mode. * * For Kepler &tm; or newer fully supported devices. * * See \ref nvmlDeviceGetAccountingStats for more details. * See \ref nvmlDeviceSetAccountingMode * * @param device The identifier of the target device * @param mode Reference in which to return the current accounting mode * * @return * - \ref NVML_SUCCESS if the mode has been successfully retrieved * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a mode are NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device doesn't support this feature * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetAccountingMode(nvmlDevice_t device, nvmlEnableState_t *mode); /** * Queries process's accounting stats. * * For Kepler &tm; or newer fully supported devices. * * Accounting stats capture GPU utilization and other statistics across the lifetime of a process. * Accounting stats can be queried during life time of the process and after its termination. * Accounting stats are kept in a circular buffer, newly created processes overwrite information about old * processes. * * See \ref nvmlAccountingStats_t for description of each returned metric. * List of processes that can be queried can be retrieved from \ref nvmlDeviceGetAccountingPids. * * @note Accounting Mode needs to be on. See \ref nvmlDeviceGetAccountingMode. * @note Only compute and graphics applications stats can be queried. Monitoring applications stats can't be * queried since they don't contribute to GPU utilization. * @note In case of pid collision stats of only the latest process (that terminated last) will be reported * * @warning On Kepler devices per process statistics are accurate only if there's one process running on a GPU. * * @param device The identifier of the target device * @param pid Process Id of the target process to query stats for * @param stats Reference in which to return the process's accounting stats * * @return * - \ref NVML_SUCCESS if stats have been successfully retrieved * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a stats are NULL * - \ref NVML_ERROR_NOT_FOUND if process stats were not found * - \ref NVML_ERROR_NOT_SUPPORTED if the device doesn't support this feature or accounting mode is disabled * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetAccountingBufferSize */ nvmlReturn_t DECLDIR nvmlDeviceGetAccountingStats(nvmlDevice_t device, unsigned int pid, nvmlAccountingStats_t *stats); /** * Queries list of processes that can be queried for accounting stats. * * For Kepler &tm; or newer fully supported devices. * * To just query the number of processes ready to be queried, call this function with *count = 0 and * pids=NULL. The return code will be NVML_ERROR_INSUFFICIENT_SIZE, or NVML_SUCCESS if list is empty. * * For more details see \ref nvmlDeviceGetAccountingStats. * * @note In case of PID collision some processes might not be accessible before the circular buffer is full. * * @param device The identifier of the target device * @param count Reference in which to provide the \a pids array size, and * to return the number of elements ready to be queried * @param pids Reference in which to return list of process ids * * @return * - \ref NVML_SUCCESS if pids were successfully retrieved * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a count is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device doesn't support this feature or accounting mode is disabled * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a count is too small (\a count is set to * expected value) * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetAccountingBufferSize */ nvmlReturn_t DECLDIR nvmlDeviceGetAccountingPids(nvmlDevice_t device, unsigned int *count, unsigned int *pids); /** * Returns the number of processes that the circular buffer with accounting pids can hold. * * For Kepler &tm; or newer fully supported devices. * * This is the maximum number of processes that accounting information will be stored for before information * about oldest processes will get overwritten by information about new processes. * * @param device The identifier of the target device * @param bufferSize Reference in which to provide the size (in number of elements) * of the circular buffer for accounting stats. * * @return * - \ref NVML_SUCCESS if buffer size was successfully retrieved * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a bufferSize is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device doesn't support this feature or accounting mode is disabled * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetAccountingStats * @see nvmlDeviceGetAccountingPids */ nvmlReturn_t DECLDIR nvmlDeviceGetAccountingBufferSize(nvmlDevice_t device, unsigned int *bufferSize); /** @} */ /** @addtogroup nvmlDeviceQueries * @{ */ /** * Returns the list of retired pages by source, including pages that are pending retirement * The address information provided from this API is the hardware address of the page that was retired. Note * that this does not match the virtual address used in CUDA, but will match the address information in XID 63 * * For Kepler &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param cause Filter page addresses by cause of retirement * @param pageCount Reference in which to provide the \a addresses buffer size, and * to return the number of retired pages that match \a cause * Set to 0 to query the size without allocating an \a addresses buffer * @param addresses Buffer to write the page addresses into * * @return * - \ref NVML_SUCCESS if \a pageCount was populated and \a addresses was filled * - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a pageCount indicates the buffer is not large enough to store all the * matching page addresses. \a pageCount is set to the needed size. * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid, \a pageCount is NULL, \a cause is invalid, or * \a addresses is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device doesn't support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetRetiredPages(nvmlDevice_t device, nvmlPageRetirementCause_t cause, unsigned int *pageCount, unsigned long long *addresses); /** * Check if any pages are pending retirement and need a reboot to fully retire. * * For Kepler &tm; or newer fully supported devices. * * @param device The identifier of the target device * @param isPending Reference in which to return the pending status * * @return * - \ref NVML_SUCCESS if \a isPending was populated * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a isPending is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the device doesn't support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceGetRetiredPagesPendingStatus(nvmlDevice_t device, nvmlEnableState_t *isPending); /** @} */ /***************************************************************************************************/ /** @defgroup nvmlUnitCommands Unit Commands * This chapter describes NVML operations that change the state of the unit. For S-class products. * Each of these requires root/admin access. Non-admin users will see an NVML_ERROR_NO_PERMISSION * error code when invoking any of these methods. * @{ */ /***************************************************************************************************/ /** * Set the LED state for the unit. The LED can be either green (0) or amber (1). * * For S-class products. * Requires root/admin permissions. * * This operation takes effect immediately. * * * Current S-Class products don't provide unique LEDs for each unit. As such, both front * and back LEDs will be toggled in unison regardless of which unit is specified with this command. * * See \ref nvmlLedColor_t for available colors. * * @param unit The identifier of the target unit * @param color The target LED color * * @return * - \ref NVML_SUCCESS if the LED color has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a unit or \a color is invalid * - \ref NVML_ERROR_NOT_SUPPORTED if this is not an S-class product * - \ref NVML_ERROR_NO_PERMISSION if the user doesn't have permission to perform this operation * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlUnitGetLedState() */ nvmlReturn_t DECLDIR nvmlUnitSetLedState(nvmlUnit_t unit, nvmlLedColor_t color); /** @} */ /***************************************************************************************************/ /** @defgroup nvmlDeviceCommands Device Commands * This chapter describes NVML operations that change the state of the device. * Each of these requires root/admin access. Non-admin users will see an NVML_ERROR_NO_PERMISSION * error code when invoking any of these methods. * @{ */ /***************************************************************************************************/ /** * Set the persistence mode for the device. * * For all products. * For Linux only. * Requires root/admin permissions. * * The persistence mode determines whether the GPU driver software is torn down after the last client * exits. * * This operation takes effect immediately. It is not persistent across reboots. After each reboot the * persistence mode is reset to "Disabled". * * See \ref nvmlEnableState_t for available modes. * * @param device The identifier of the target device * @param mode The target persistence mode * * @return * - \ref NVML_SUCCESS if the persistence mode was set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a mode is invalid * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_NO_PERMISSION if the user doesn't have permission to perform this operation * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetPersistenceMode() */ nvmlReturn_t DECLDIR nvmlDeviceSetPersistenceMode(nvmlDevice_t device, nvmlEnableState_t mode); /** * Set the compute mode for the device. * * For all products. * Requires root/admin permissions. * * The compute mode determines whether a GPU can be used for compute operations and whether it can * be shared across contexts. * * This operation takes effect immediately. Under Linux it is not persistent across reboots and * always resets to "Default". Under windows it is persistent. * * Under windows compute mode may only be set to DEFAULT when running in WDDM * * See \ref nvmlComputeMode_t for details on available compute modes. * * @param device The identifier of the target device * @param mode The target compute mode * * @return * - \ref NVML_SUCCESS if the compute mode was set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a mode is invalid * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_NO_PERMISSION if the user doesn't have permission to perform this operation * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetComputeMode() */ nvmlReturn_t DECLDIR nvmlDeviceSetComputeMode(nvmlDevice_t device, nvmlComputeMode_t mode); /** * Set the ECC mode for the device. * * For Kepler &tm; or newer fully supported devices. * Only applicable to devices with ECC. * Requires \a NVML_INFOROM_ECC version 1.0 or higher. * Requires root/admin permissions. * * The ECC mode determines whether the GPU enables its ECC support. * * This operation takes effect after the next reboot. * * See \ref nvmlEnableState_t for details on available modes. * * @param device The identifier of the target device * @param ecc The target ECC mode * * @return * - \ref NVML_SUCCESS if the ECC mode was set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a ecc is invalid * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_NO_PERMISSION if the user doesn't have permission to perform this operation * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetEccMode() */ nvmlReturn_t DECLDIR nvmlDeviceSetEccMode(nvmlDevice_t device, nvmlEnableState_t ecc); /** * Clear the ECC error and other memory error counts for the device. * * For Kepler &tm; or newer fully supported devices. * Only applicable to devices with ECC. * Requires \a NVML_INFOROM_ECC version 2.0 or higher to clear aggregate location-based ECC counts. * Requires \a NVML_INFOROM_ECC version 1.0 or higher to clear all other ECC counts. * Requires root/admin permissions. * Requires ECC Mode to be enabled. * * Sets all of the specified ECC counters to 0, including both detailed and total counts. * * This operation takes effect immediately. * * See \ref nvmlMemoryErrorType_t for details on available counter types. * * @param device The identifier of the target device * @param counterType Flag that indicates which type of errors should be cleared. * * @return * - \ref NVML_SUCCESS if the error counts were cleared * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a counterType is invalid * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_NO_PERMISSION if the user doesn't have permission to perform this operation * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see * - nvmlDeviceGetDetailedEccErrors() * - nvmlDeviceGetTotalEccErrors() */ nvmlReturn_t DECLDIR nvmlDeviceClearEccErrorCounts(nvmlDevice_t device, nvmlEccCounterType_t counterType); /** * Set the driver model for the device. * * For Fermi &tm; or newer fully supported devices. * For windows only. * Requires root/admin permissions. * * On Windows platforms the device driver can run in either WDDM or WDM (TCC) mode. If a display is attached * to the device it must run in WDDM mode. * * It is possible to force the change to WDM (TCC) while the display is still attached with a force flag (nvmlFlagForce). * This should only be done if the host is subsequently powered down and the display is detached from the device * before the next reboot. * * This operation takes effect after the next reboot. * * Windows driver model may only be set to WDDM when running in DEFAULT compute mode. * * Change driver model to WDDM is not supported when GPU doesn't support graphics acceleration or * will not support it after reboot. See \ref nvmlDeviceSetGpuOperationMode. * * See \ref nvmlDriverModel_t for details on available driver models. * See \ref nvmlFlagDefault and \ref nvmlFlagForce * * @param device The identifier of the target device * @param driverModel The target driver model * @param flags Flags that change the default behavior * * @return * - \ref NVML_SUCCESS if the driver model has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a driverModel is invalid * - \ref NVML_ERROR_NOT_SUPPORTED if the platform is not windows or the device does not support this feature * - \ref NVML_ERROR_NO_PERMISSION if the user doesn't have permission to perform this operation * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetDriverModel() */ nvmlReturn_t DECLDIR nvmlDeviceSetDriverModel(nvmlDevice_t device, nvmlDriverModel_t driverModel, unsigned int flags); /** * Set clocks that applications will lock to. * * Sets the clocks that compute and graphics applications will be running at. * e.g. CUDA driver requests these clocks during context creation which means this property * defines clocks at which CUDA applications will be running unless some overspec event * occurs (e.g. over power, over thermal or external HW brake). * * Can be used as a setting to request constant performance. * * For Kepler &tm; or newer non-GeForce fully supported devices and Maxwell or newer GeForce devices. * Requires root/admin permissions. * * See \ref nvmlDeviceGetSupportedMemoryClocks and \ref nvmlDeviceGetSupportedGraphicsClocks * for details on how to list available clocks combinations. * * After system reboot or driver reload applications clocks go back to their default value. * See \ref nvmlDeviceResetApplicationsClocks. * * @param device The identifier of the target device * @param memClockMHz Requested memory clock in MHz * @param graphicsClockMHz Requested graphics clock in MHz * * @return * - \ref NVML_SUCCESS if new settings were successfully set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a memClockMHz and \a graphicsClockMHz * is not a valid clock combination * - \ref NVML_ERROR_NO_PERMISSION if the user doesn't have permission to perform this operation * - \ref NVML_ERROR_NOT_SUPPORTED if the device doesn't support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceSetApplicationsClocks(nvmlDevice_t device, unsigned int memClockMHz, unsigned int graphicsClockMHz); /** * Set new power limit of this device. * * For Kepler &tm; or newer fully supported devices. * Requires root/admin permissions. * * See \ref nvmlDeviceGetPowerManagementLimitConstraints to check the allowed ranges of values. * * \note Limit is not persistent across reboots or driver unloads. * Enable persistent mode to prevent driver from unloading when no application is using the device. * * @param device The identifier of the target device * @param limit Power management limit in milliwatts to set * * @return * - \ref NVML_SUCCESS if \a limit has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a defaultLimit is out of range * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support this feature * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceGetPowerManagementLimitConstraints * @see nvmlDeviceGetPowerManagementDefaultLimit */ nvmlReturn_t DECLDIR nvmlDeviceSetPowerManagementLimit(nvmlDevice_t device, unsigned int limit); /** * Sets new GOM. See \a nvmlGpuOperationMode_t for details. * * For GK110 M-class and X-class Tesla &tm; products from the Kepler family. * Modes \ref NVML_GOM_LOW_DP and \ref NVML_GOM_ALL_ON are supported on fully supported GeForce products. * Not supported on Quadro ® and Tesla &tm; C-class products. * Requires root/admin permissions. * * Changing GOMs requires a reboot. * The reboot requirement might be removed in the future. * * Compute only GOMs don't support graphics acceleration. Under windows switching to these GOMs when * pending driver model is WDDM is not supported. See \ref nvmlDeviceSetDriverModel. * * @param device The identifier of the target device * @param mode Target GOM * * @return * - \ref NVML_SUCCESS if \a mode has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a mode incorrect * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support GOM or specific mode * - \ref NVML_ERROR_NO_PERMISSION if the user doesn't have permission to perform this operation * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlGpuOperationMode_t * @see nvmlDeviceGetGpuOperationMode */ nvmlReturn_t DECLDIR nvmlDeviceSetGpuOperationMode(nvmlDevice_t device, nvmlGpuOperationMode_t mode); /** * Changes the root/admin restructions on certain APIs. See \a nvmlRestrictedAPI_t for the list of supported APIs. * This method can be used by a root/admin user to give non-root/admin access to certain otherwise-restricted APIs. * The new setting lasts for the lifetime of the NVIDIA driver; it is not persistent. See \a nvmlDeviceGetAPIRestriction * to query the current restriction settings. * * For Kepler &tm; or newer fully supported devices. * Requires root/admin permissions. * * @param device The identifier of the target device * @param apiType Target API type for this operation * @param isRestricted The target restriction * * @return * - \ref NVML_SUCCESS if \a isRestricted has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device is invalid or \a apiType incorrect * - \ref NVML_ERROR_NOT_SUPPORTED if the device does not support changing API restrictions or the device does not support * the feature that api restrictions are being set for (E.G. Enabling/disabling auto * boosted clocks is not supported by the device) * - \ref NVML_ERROR_NO_PERMISSION if the user doesn't have permission to perform this operation * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlRestrictedAPI_t */ nvmlReturn_t DECLDIR nvmlDeviceSetAPIRestriction(nvmlDevice_t device, nvmlRestrictedAPI_t apiType, nvmlEnableState_t isRestricted); /** * @} */ /** @addtogroup nvmlAccountingStats * @{ */ /** * Enables or disables per process accounting. * * For Kepler &tm; or newer fully supported devices. * Requires root/admin permissions. * * @note This setting is not persistent and will default to disabled after driver unloads. * Enable persistence mode to be sure the setting doesn't switch off to disabled. * * @note Enabling accounting mode has no negative impact on the GPU performance. * * @note Disabling accounting clears all accounting pids information. * * See \ref nvmlDeviceGetAccountingMode * See \ref nvmlDeviceGetAccountingStats * See \ref nvmlDeviceClearAccountingPids * * @param device The identifier of the target device * @param mode The target accounting mode * * @return * - \ref NVML_SUCCESS if the new mode has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device or \a mode are invalid * - \ref NVML_ERROR_NOT_SUPPORTED if the device doesn't support this feature * - \ref NVML_ERROR_NO_PERMISSION if the user doesn't have permission to perform this operation * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceSetAccountingMode(nvmlDevice_t device, nvmlEnableState_t mode); /** * Clears accounting information about all processes that have already terminated. * * For Kepler &tm; or newer fully supported devices. * Requires root/admin permissions. * * See \ref nvmlDeviceGetAccountingMode * See \ref nvmlDeviceGetAccountingStats * See \ref nvmlDeviceSetAccountingMode * * @param device The identifier of the target device * * @return * - \ref NVML_SUCCESS if accounting information has been cleared * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a device are invalid * - \ref NVML_ERROR_NOT_SUPPORTED if the device doesn't support this feature * - \ref NVML_ERROR_NO_PERMISSION if the user doesn't have permission to perform this operation * - \ref NVML_ERROR_UNKNOWN on any unexpected error */ nvmlReturn_t DECLDIR nvmlDeviceClearAccountingPids(nvmlDevice_t device); /** @} */ /***************************************************************************************************/ /** @defgroup nvmlEvents Event Handling Methods * This chapter describes methods that NVML can perform against each device to register and wait for * some event to occur. * @{ */ /***************************************************************************************************/ /** * Create an empty set of events. * Event set should be freed by \ref nvmlEventSetFree * * For Fermi &tm; or newer fully supported devices. * @param set Reference in which to return the event handle * * @return * - \ref NVML_SUCCESS if the event has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a set is NULL * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlEventSetFree */ nvmlReturn_t DECLDIR nvmlEventSetCreate(nvmlEventSet_t *set); /** * Starts recording of events on a specified devices and add the events to specified \ref nvmlEventSet_t * * For Fermi &tm; or newer fully supported devices. * Ecc events are available only on ECC enabled devices (see \ref nvmlDeviceGetTotalEccErrors) * Power capping events are available only on Power Management enabled devices (see \ref nvmlDeviceGetPowerManagementMode) * * For Linux only. * * \b IMPORTANT: Operations on \a set are not thread safe * * This call starts recording of events on specific device. * All events that occurred before this call are not recorded. * Checking if some event occurred can be done with \ref nvmlEventSetWait * * If function reports NVML_ERROR_UNKNOWN, event set is in undefined state and should be freed. * If function reports NVML_ERROR_NOT_SUPPORTED, event set can still be used. None of the requested eventTypes * are registered in that case. * * @param device The identifier of the target device * @param eventTypes Bitmask of \ref nvmlEventType to record * @param set Set to which add new event types * * @return * - \ref NVML_SUCCESS if the event has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a eventTypes is invalid or \a set is NULL * - \ref NVML_ERROR_NOT_SUPPORTED if the platform does not support this feature or some of requested event types * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlEventType * @see nvmlDeviceGetSupportedEventTypes * @see nvmlEventSetWait * @see nvmlEventSetFree */ nvmlReturn_t DECLDIR nvmlDeviceRegisterEvents(nvmlDevice_t device, unsigned long long eventTypes, nvmlEventSet_t set); /** * Returns information about events supported on device * * For Fermi &tm; or newer fully supported devices. * * Events are not supported on Windows. So this function returns an empty mask in \a eventTypes on Windows. * * @param device The identifier of the target device * @param eventTypes Reference in which to return bitmask of supported events * * @return * - \ref NVML_SUCCESS if the eventTypes has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a eventType is NULL * - \ref NVML_ERROR_GPU_IS_LOST if the target GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlEventType * @see nvmlDeviceRegisterEvents */ nvmlReturn_t DECLDIR nvmlDeviceGetSupportedEventTypes(nvmlDevice_t device, unsigned long long *eventTypes); /** * Waits on events and delivers events * * For Fermi &tm; or newer fully supported devices. * * If some events are ready to be delivered at the time of the call, function returns immediately. * If there are no events ready to be delivered, function sleeps till event arrives * but not longer than specified timeout. This function in certain conditions can return before * specified timeout passes (e.g. when interrupt arrives) * * In case of xid error, the function returns the most recent xid error type seen by the system. If there are multiple * xid errors generated before nvmlEventSetWait is invoked then the last seen xid error type is returned for all * xid error events. * * @param set Reference to set of events to wait on * @param data Reference in which to return event data * @param timeoutms Maximum amount of wait time in milliseconds for registered event * * @return * - \ref NVML_SUCCESS if the data has been set * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_INVALID_ARGUMENT if \a data is NULL * - \ref NVML_ERROR_TIMEOUT if no event arrived in specified timeout or interrupt arrived * - \ref NVML_ERROR_GPU_IS_LOST if a GPU has fallen off the bus or is otherwise inaccessible * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlEventType * @see nvmlDeviceRegisterEvents */ nvmlReturn_t DECLDIR nvmlEventSetWait(nvmlEventSet_t set, nvmlEventData_t * data, unsigned int timeoutms); /** * Releases events in the set * * For Fermi &tm; or newer fully supported devices. * * @param set Reference to events to be released * * @return * - \ref NVML_SUCCESS if the event has been successfully released * - \ref NVML_ERROR_UNINITIALIZED if the library has not been successfully initialized * - \ref NVML_ERROR_UNKNOWN on any unexpected error * * @see nvmlDeviceRegisterEvents */ nvmlReturn_t DECLDIR nvmlEventSetFree(nvmlEventSet_t set); /** @} */ /** * NVML API versioning support */ #if defined(__NVML_API_VERSION_INTERNAL) #undef nvmlDeviceGetPciInfo #undef nvmlDeviceGetCount #undef nvmlDeviceGetHandleByIndex #undef nvmlDeviceGetHandleByPciBusId #undef nvmlInit #endif #ifdef __cplusplus } #endif #endif thinkfan-1.3.1/rcscripts/000077500000000000000000000000001417751172400153435ustar00rootroot00000000000000thinkfan-1.3.1/rcscripts/openrc/000077500000000000000000000000001417751172400166315ustar00rootroot00000000000000thinkfan-1.3.1/rcscripts/openrc/thinkfan.cmake000066400000000000000000000005241417751172400214360ustar00rootroot00000000000000#!/sbin/openrc-run command="@CMAKE_INSTALL_PREFIX@/sbin/thinkfan" command_args="-q -s5 -c /etc/thinkfan.conf" pidfile="@PID_FILE@" extra_started_commands="reload" required_files="/etc/thinkfan.conf" depend() { after modules } reload() { ebegin "Reloading ${SVCNAME}" start-stop-daemon --signal HUP --pidfile "${pidfile}" eend $? } thinkfan-1.3.1/rcscripts/systemd/000077500000000000000000000000001417751172400170335ustar00rootroot00000000000000thinkfan-1.3.1/rcscripts/systemd/override.conf000066400000000000000000000002701417751172400215200ustar00rootroot00000000000000[Service] # Decrease biasing (up to -b-10) if your fan speed changes too quickly, # Increase biasing (up to -b20) if your fan speed changes too slowly. Environment='THINKFAN_ARGS=-b0' thinkfan-1.3.1/rcscripts/systemd/thinkfan-sleep.service000066400000000000000000000004271417751172400233300ustar00rootroot00000000000000[Unit] Description=Notify thinkfan of imminent sleep Before=sleep.target [Service] Type=oneshot ExecStart=/usr/bin/pkill -x -winch thinkfan # Hack: Since the signal handler races with the sleep, we need to delay a bit ExecStart=/usr/bin/sleep 1 [Install] WantedBy=sleep.target thinkfan-1.3.1/rcscripts/systemd/thinkfan-wakeup.service000066400000000000000000000004431417751172400235120ustar00rootroot00000000000000[Unit] Description=Reload thinkfan after waking up from suspend After=sysinit.target After=suspend.target After=suspend-then-hibernate.target After=hybrid-sleep.target After=hibernate.target [Service] Type=oneshot ExecStart=/usr/bin/pkill -x -usr2 thinkfan [Install] WantedBy=sleep.target thinkfan-1.3.1/rcscripts/systemd/thinkfan.service.cmake000066400000000000000000000005311417751172400232750ustar00rootroot00000000000000[Unit] Description=thinkfan @THINKFAN_VERSION@ After=sysinit.target After=systemd-modules-load.service [Service] Type=forking ExecStart=@CMAKE_INSTALL_PREFIX@/sbin/thinkfan $THINKFAN_ARGS PIDFile=/run/thinkfan.pid ExecReload=/bin/kill -HUP $MAINPID [Install] WantedBy=multi-user.target Also=thinkfan-sleep.service Also=thinkfan-wakeup.service thinkfan-1.3.1/rcscripts/sysvinit/000077500000000000000000000000001417751172400172335ustar00rootroot00000000000000thinkfan-1.3.1/rcscripts/sysvinit/thinkfan.default000066400000000000000000000004421417751172400224030ustar00rootroot00000000000000# Should thinkfan be started automatically on boot? # Only say "yes" when you know what you are doing, have configured # thinkfan correctly for *YOUR* machine and loaded thinkpad_acpi # with fan_control=1 (if you have a ThinkPad). START=no # Additional startup parameters DAEMON_ARGS="-q" thinkfan-1.3.1/rcscripts/sysvinit/thinkfan.init000066400000000000000000000076051417751172400217320ustar00rootroot00000000000000#! /bin/sh ### BEGIN INIT INFO # Provides: thinkfan # Required-Start: $remote_fs # Required-Stop: $remote_fs # Default-Start: 2 3 4 5 # Default-Stop: 0 1 6 # Short-Description: thinkfan initscript # Description: starts thinkfan if enabled in /etc/default/thinkfan ### END INIT INFO # Author: Evgeni Golov # Do NOT "set -e" # PATH should only include /usr/* if it runs after the mountnfs.sh script PATH=/sbin:/usr/sbin:/bin:/usr/bin DESC="fan control tool" NAME=thinkfan DAEMON=/usr/sbin/$NAME DAEMON_ARGS="-q" # This one is compiled-in, you can't change it here! PIDFILE=/var/run/$NAME.pid SCRIPTNAME=/etc/init.d/$NAME START=no # Exit if the package is not installed [ -x "$DAEMON" ] || exit 0 # Read configuration variable file if it is present [ -r /etc/default/$NAME ] && . /etc/default/$NAME # Check if daemon is to be started [ "$START" = "yes" ] || exit 0 # Load the VERBOSE setting and other rcS variables . /lib/init/vars.sh # Define LSB log_* functions. # Depend on lsb-base (>= 3.0-6) to ensure that this file is present. . /lib/lsb/init-functions # # Function that starts the daemon/service # do_start() { # Return # 0 if daemon has been started # 1 if daemon was already running # 2 if daemon could not be started start-stop-daemon --start --quiet --pidfile $PIDFILE --exec $DAEMON --test > /dev/null \ || return 1 start-stop-daemon --start --quiet --pidfile $PIDFILE --exec $DAEMON -- \ $DAEMON_ARGS \ || return 2 # Add code here, if necessary, that waits for the process to be ready # to handle requests from services started subsequently which depend # on this one. As a last resort, sleep for some time. } # # Function that stops the daemon/service # do_stop() { # Return # 0 if daemon has been stopped # 1 if daemon was already stopped # 2 if daemon could not be stopped # other if a failure occurred start-stop-daemon --stop --quiet --retry=TERM/30/KILL/5 --pidfile $PIDFILE --name $NAME RETVAL="$?" [ "$RETVAL" = 2 ] && return 2 # Wait for children to finish too if this is a daemon that forks # and if the daemon is only ever run from this initscript. # If the above conditions are not satisfied then add some other code # that waits for the process to drop all resources that could be # needed by services started subsequently. A last resort is to # sleep for some time. start-stop-daemon --stop --quiet --oknodo --retry=0/30/KILL/5 --exec $DAEMON [ "$?" = 2 ] && return 2 # Many daemons don't delete their pidfiles when they exit. rm -f $PIDFILE return "$RETVAL" } # # Function that sends a SIGHUP to the daemon/service # do_reload() { # # If the daemon can reload its configuration without # restarting (for example, when it is sent a SIGHUP), # then implement that here. # start-stop-daemon --stop --signal 1 --quiet --pidfile $PIDFILE --name $NAME return 0 } case "$1" in start) [ "$VERBOSE" != no ] && log_daemon_msg "Starting $DESC" "$NAME" do_start case "$?" in 0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;; 2) [ "$VERBOSE" != no ] && log_end_msg 1 ;; esac ;; stop) [ "$VERBOSE" != no ] && log_daemon_msg "Stopping $DESC" "$NAME" do_stop case "$?" in 0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;; 2) [ "$VERBOSE" != no ] && log_end_msg 1 ;; esac ;; status) status_of_proc "$DAEMON" "$NAME" && exit 0 || exit $? ;; reload|force-reload) log_daemon_msg "Reloading $DESC" "$NAME" do_reload log_end_msg $? ;; restart) log_daemon_msg "Restarting $DESC" "$NAME" do_stop case "$?" in 0|1) do_start case "$?" in 0) log_end_msg 0 ;; 1) log_end_msg 1 ;; # Old process is still running *) log_end_msg 1 ;; # Failed to start esac ;; *) # Failed to stop log_end_msg 1 ;; esac ;; *) #echo "Usage: $SCRIPTNAME {start|stop|restart|reload|force-reload}" >&2 echo "Usage: $SCRIPTNAME {start|stop|restart|status|restart|force-reload}" >&2 exit 3 ;; esac : thinkfan-1.3.1/src/000077500000000000000000000000001417751172400141165ustar00rootroot00000000000000thinkfan-1.3.1/src/config.cpp000066400000000000000000000262571417751172400161030ustar00rootroot00000000000000/******************************************************************** * config.cpp: Config data structures and consistency checking. * (C) 2015, Victor Mataré * * this file is part of thinkfan. See thinkfan.c for further information. * * thinkfan is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * thinkfan 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. * * You should have received a copy of the GNU General Public License * along with thinkfan. If not, see . * * ******************************************************************/ #include "config.h" #include #include #include #include #include #include #include "parser.h" #include "message.h" #include "thinkfan.h" #ifdef USE_YAML #include "yamlconfig.h" #endif namespace thinkfan { FanConfig::FanConfig(unique_ptr &&fan_drv) : fan_(std::move(fan_drv)) {} const unique_ptr &FanConfig::fan() const { return fan_; } void FanConfig::set_fan(unique_ptr &&fan) { fan_ = std::move(fan); } StepwiseMapping::StepwiseMapping(unique_ptr &&fan_drv) : FanConfig(std::move(fan_drv)) {} const vector> &StepwiseMapping::levels() const { return levels_; } void StepwiseMapping::init_fanspeed(const TemperatureState &ts) { cur_lvl_ = --levels().end(); while (cur_lvl_ != levels().begin() && (*cur_lvl_)->down(ts)) cur_lvl_--; fan()->set_speed(**cur_lvl_); } bool StepwiseMapping::set_fanspeed(const TemperatureState &ts) { if (unlikely(cur_lvl_ != --levels().end() && (*cur_lvl_)->up(ts))) { while (cur_lvl_ != --levels().end() && (*cur_lvl_)->up(ts)) cur_lvl_++; fan()->set_speed(**cur_lvl_); return true; } else if (unlikely(cur_lvl_ != levels().begin() && (*cur_lvl_)->down(ts))) { while (cur_lvl_ != levels().begin() && (*cur_lvl_)->down(ts)) cur_lvl_--; fan()->set_speed(**cur_lvl_); tmp_sleeptime = sleeptime; return true; } else { fan()->ping_watchdog_and_depulse(**cur_lvl_); return false; } } void StepwiseMapping::ensure_consistency(const Config &config) const { if (levels().size() == 0) throw ConfigError("No fan levels specified."); if (!fan()) throw ConfigError("No fan specified in stepwise mapping."); for (auto &lvl : levels()) lvl->ensure_consistency(config); int maxlvl = (*levels_.rbegin())->num(); if (dynamic_cast(fan().get()) && maxlvl < 128) error(MSG_CONF_MAXLVL((*levels_.rbegin())->num())); else if (dynamic_cast(fan().get()) && maxlvl != std::numeric_limits::max() && maxlvl > 7 && maxlvl != 127) error(MSG_CONF_TP_LVL7(maxlvl, 7)); } void StepwiseMapping::add_level(unique_ptr &&level) { if (levels_.size() > 0) { const unique_ptr &last_lvl = levels_.back(); if (level->num() != std::numeric_limits::max() && level->num() != std::numeric_limits::min() && last_lvl->num() > level->num()) error(MSG_CONF_LVLORDER); if (last_lvl->upper_limit().size() != level->upper_limit().size()) error(MSG_CONF_LVLORDER); for (vector::const_iterator mit = last_lvl->upper_limit().begin(), oit = level->lower_limit().begin(); mit != last_lvl->upper_limit().end() && oit != level->lower_limit().end(); ++mit, ++oit) { if (*mit < *oit) error(MSG_CONF_OVERLAP); } } levels_.push_back(std::move(level)); } Config::Config() : num_temps_(0) {} const Config *Config::read_config(const vector &filenames) { const Config *rv = nullptr; for (auto it = filenames.begin(); it != filenames.end(); ++it) { try { rv = try_read_config(*it); break; } catch (IOerror &e) { if (e.code() != ENOENT || it+1 >= filenames.end()) throw; } } return rv; } const Config *Config::try_read_config(const string &filename) { Config *rv = nullptr; ifstream f_in(filename); if (!(f_in.is_open() && f_in.good())) throw IOerror(filename + ": ", errno); if (!f_in.seekg(0, f_in.end)) throw IOerror(filename + ": ", errno); ifstream::pos_type f_size = f_in.tellg(); if (!f_in.seekg(0, f_in.beg)) throw IOerror(filename + ": ", errno); string f_data; f_data.resize(f_size, 0); if (!f_in.read(&*f_data.begin(), f_size)) throw IOerror(filename + ": ", errno); #ifdef USE_YAML try { YAML::Node root = YAML::Load(f_data); // Copy the return value first. Workaround for https://github.com/vmatare/thinkfan/issues/42 // due to bug in ancient yaml-cpp: https://github.com/jbeder/yaml-cpp/commit/97d56c3f3608331baaee26e17d2f116d799a7edc try { YAML::wtf_ptr rv_tmp = root.as>(); rv = rv_tmp.release(); } catch (IOerror &e) { // An IOerror while processing the config means that an invalid sensor or fan path was specified. // That's a user error, wrap it and let it escalate. throw ConfigError(e.what()); } #if not defined(DISABLE_EXCEPTION_CATCHING) } catch(YamlError &e) { throw ConfigError(filename, e.mark, f_data, e.what()); } catch(YAML::RepresentationException &e) { throw ConfigError(filename, e.mark, f_data, "Invalid entry"); #endif } catch(YAML::ParserException &e) { string::size_type ext_off = filename.rfind('.'); if (ext_off != string::npos) { string ext = filename.substr(filename.rfind('.')); std::for_each(ext.begin(), ext.end(), [] (char &c) { c = std::toupper(c, std::locale()); } ); if (ext == ".YAML") throw ConfigError(filename, e.mark, f_data, e.what()); } #endif //USE_YAML ConfigParser parser; const char *input = f_data.c_str(); const char *start = input; rv = parser.parse_config(input); if (!rv) { throw SyntaxError(filename, parser.get_max_addr() - start, f_data); } #ifdef USE_YAML } #endif //USE_YAML rv->src_file = filename; rv->ensure_consistency(); return rv; } void Config::ensure_consistency() const { // Consistency checks which require the complete config if (fan_configs().empty()) throw ConfigError("No fans are configured in " + src_file); for (const unique_ptr &fan_cfg : fan_configs()) try { fan_cfg->ensure_consistency(*this); } catch (ConfigError &err) { err.set_filename(src_file); throw; } if (sensors().size() < 1) throw ConfigError(src_file + ": " + MSG_NO_SENSOR); } void Config::add_sensor(unique_ptr &&sensor) { num_temps_ += sensor->num_temps(); sensors_.push_back(std::move(sensor)); } unsigned int Config::num_temps() const { return num_temps_; } const vector> &Config::sensors() const { return sensors_; } const vector> &Config::fan_configs() const { return temp_mappings_; } void Config::add_fan_config(unique_ptr &&fan_cfg) { temp_mappings_.push_back(std::move(fan_cfg)); } void Config::init_fans() const { for (const unique_ptr &fan_cfg : fan_configs()) fan_cfg->fan()->init(); } Level::Level(int level, int lower_limit, int upper_limit) : Level(level, vector(1, lower_limit), vector(1, upper_limit)) {} Level::Level(string level, int lower_limit, int upper_limit) : Level(level, vector(1, lower_limit), vector(1, upper_limit)) {} Level::Level(int level, const vector &lower_limit, const vector &upper_limit) : level_s_("level " + std::to_string(level)), level_n_(level), lower_limit_(lower_limit), upper_limit_(upper_limit) {} Level::Level(string level, const vector &lower_limit, const vector &upper_limit) : level_s_(level), level_n_(string_to_int(level_s_)), lower_limit_(lower_limit), upper_limit_(upper_limit) { if (lower_limit.size() != upper_limit.size()) error(MSG_CONF_LIMITLEN); for (vector::const_iterator l_it = lower_limit.begin(), u_it = upper_limit.begin(); l_it != lower_limit.end() && u_it != upper_limit.end(); ++u_it, ++l_it) { if (*l_it != numeric_limits::max() && *l_it >= *u_it) error(MSG_CONF_LOWHIGH); } } int Level::string_to_int(string &level) { int rv; if (level == "level auto" || level == "level disengaged" || level == "level full-speed") return std::numeric_limits::min(); else if (sscanf(level.c_str(), "level %d", &rv) == 1) return rv; else try { rv = std::stoi(level); level = "level " + level; } catch (std::out_of_range &) { error(MSG_CONF_LVLFORMAT(level)); } catch (std::invalid_argument &) { error(MSG_CONF_LVLFORMAT(level)); } return rv; } const vector &Level::lower_limit() const { return lower_limit_; } const vector &Level::upper_limit() const { return upper_limit_; } const string &Level::str() const { return this->level_s_; } int Level::num() const { return this->level_n_; } SimpleLevel::SimpleLevel(int level, int lower_limit, int upper_limit) : Level(level, lower_limit, upper_limit) {} SimpleLevel::SimpleLevel(string level, int lower_limit, int upper_limit) : Level(level, lower_limit, upper_limit) {} bool SimpleLevel::up(const TemperatureState &temp_state) const { return *temp_state.tmax >= upper_limit().front(); } bool SimpleLevel::down(const TemperatureState &temp_state) const { return *temp_state.tmax < lower_limit().front(); } void SimpleLevel::ensure_consistency(const Config &) const {} ComplexLevel::ComplexLevel(int level, const vector &lower_limit, const vector &upper_limit) : Level(level, lower_limit, upper_limit) {} ComplexLevel::ComplexLevel(string level, const vector &lower_limit, const vector &upper_limit) : Level(level, lower_limit, upper_limit) {} bool ComplexLevel::up(const TemperatureState &temp_state) const { vector::const_iterator temp_it = temp_state.biased_temps().begin(); auto upper_it = upper_limit().begin(); while (temp_it != temp_state.biased_temps().end()) if (*temp_it++ >= *upper_it++) return true; return false; } bool ComplexLevel::down(const TemperatureState &temp_state) const { auto temp_it = temp_state.biased_temps().begin(); auto lower_it = lower_limit().begin(); while (temp_it != temp_state.biased_temps().end() && *temp_it < *lower_it) { temp_it++; lower_it++; } return temp_it == temp_state.biased_temps().end(); } void ComplexLevel::ensure_consistency(const Config &cfg) const { string limitstr; const string restmsg = " must have the length " + std::to_string(cfg.num_temps()) + " (one entry for each configured sensor)" ; if (lower_limit().size() != cfg.num_temps()) throw ConfigError( "Lower limit " + format_limit(lower_limit()) + restmsg ); if (upper_limit().size() != cfg.num_temps()) throw ConfigError( "Upper limit " + format_limit(upper_limit()) + restmsg ); } string ComplexLevel::format_limit(const vector &limit) { return "[" + std::accumulate( std::next(limit.begin()), limit.end(), std::to_string(limit.front()), [] (string l, int r) -> string { return std::move(l) + ", " + std::to_string(r); } ) + "]"; } } /* namespace thinkfan */ thinkfan-1.3.1/src/config.h000066400000000000000000000110761417751172400155410ustar00rootroot00000000000000/******************************************************************** * config.h: Config data structures and consistency checking. * (C) 2015, Victor Mataré * * this file is part of thinkfan. See thinkfan.c for further information. * * thinkfan is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * thinkfan 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. * * You should have received a copy of the GNU General Public License * along with thinkfan. If not, see . * * ******************************************************************/ #ifndef THINKFAN_CONFIG_H_ #define THINKFAN_CONFIG_H_ #include "error.h" #include #include #include #include #include "fans.h" #include "sensors.h" #include "thinkfan.h" namespace thinkfan { class Config; class FanConfig { public: FanConfig(unique_ptr && = nullptr); virtual ~FanConfig() = default; virtual void init_fanspeed(const TemperatureState &) = 0; virtual bool set_fanspeed(const TemperatureState &) = 0; virtual void ensure_consistency(const Config &) const = 0; void set_fan(unique_ptr &&); const unique_ptr &fan() const; private: unique_ptr fan_; }; class StepwiseMapping : public FanConfig { public: StepwiseMapping(unique_ptr && = nullptr); virtual ~StepwiseMapping() override = default; virtual void init_fanspeed(const TemperatureState &) override; virtual bool set_fanspeed(const TemperatureState &) override; virtual void ensure_consistency(const Config &) const override; void add_level(unique_ptr &&level); const vector> &levels() const; private: vector> levels_; vector>::const_iterator cur_lvl_; }; class Level { protected: string level_s_; int level_n_; vector lower_limit_; vector upper_limit_; public: Level(int level, int lower_limit, int upper_limit); Level(string level, int lower_limit, int upper_limit); Level(int level, const vector &lower_limit, const vector &upper_limit); Level(string level, const vector &lower_limit, const vector &upper_limit); virtual ~Level() = default; const vector &lower_limit() const; const vector &upper_limit() const; virtual bool up(const TemperatureState &) const = 0; virtual bool down(const TemperatureState &) const = 0; virtual void ensure_consistency(const Config &) const = 0; const string &str() const; int num() const; static int string_to_int(string &level); }; class SimpleLevel : public Level { public: SimpleLevel(int level, int lower_limit, int upper_limit); SimpleLevel(string level, int lower_limit, int upper_limit); virtual bool up(const TemperatureState &) const override; virtual bool down(const TemperatureState &) const override; virtual void ensure_consistency(const Config &) const override; }; class ComplexLevel : public Level { public: ComplexLevel(int level, const vector &lower_limit, const vector &upper_limit); ComplexLevel(string level, const vector &lower_limit, const vector &upper_limit); virtual bool up(const TemperatureState &) const override; virtual bool down(const TemperatureState &) const override; virtual void ensure_consistency(const Config &) const override; private: static string format_limit(const vector &limit); }; class Config { public: Config(); // Not trivially copyable since it holds raw pointers to levels, drivers and fans. Config(const Config &) = delete; ~Config() = default; static const Config *read_config(const vector &filenames); void add_sensor(unique_ptr &&sensor); void add_fan_config(unique_ptr &&fan_cfg); void ensure_consistency() const; void init_fans() const; unsigned int num_temps() const; const vector> &sensors() const; const vector> &fan_configs() const; // No copy assignment operator either (not required). Config &operator = (const Config &) = delete; string src_file; private: static const Config *try_read_config(const string &data); vector> sensors_; vector> temp_mappings_; unsigned int num_temps_; }; } #endif /* THINKFAN_CONFIG_H_ */ thinkfan-1.3.1/src/error.cpp000066400000000000000000000132171417751172400157570ustar00rootroot00000000000000/******************************************************************** * error.cpp: Custom exceptions * (C) 2015, Victor Mataré * * this file is part of thinkfan. See thinkfan.c for further information. * * thinkfan is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * thinkfan 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. * * You should have received a copy of the GNU General Public License * along with thinkfan. If not, see . * * ******************************************************************/ #include "error.h" #include #if defined(__GLIBC__) #include #endif #include #include #include #ifdef __GNUG__ #include #include #include #endif namespace thinkfan { static string make_backtrace() { #if defined(__GLIBC__) string backtrace_; void *bt_buffer[MAX_BACKTRACE_DEPTH]; int stack_depth = ::backtrace(bt_buffer, MAX_BACKTRACE_DEPTH); if (stack_depth == MAX_BACKTRACE_DEPTH) log(TF_ERR) << "Max backtrace depth reached. Backtrace may be incomplete." << flush; char **bt_pretty = backtrace_symbols(bt_buffer, stack_depth); for (int i=0; i < stack_depth; ++i) { string line(bt_pretty[i]); string::size_type i1 = line.rfind('('); string::size_type i2 = line.rfind('+'); if (i1 != string::npos && i2 != string::npos && i2 - i1 > 1 && line[i1+1] != '+') // line contains a function name to demangle line = line.substr(0, i1+1) + demangle(line.substr(i1+1, i2-i1-1).c_str()) + line.substr(i2); backtrace_ += line; backtrace_ += '\n'; } free(bt_pretty); return backtrace_; #else return "[not supported by C library]"; #endif } #ifdef __GNUG__ // Cf. http://stackoverflow.com/questions/281818/unmangling-the-result-of-stdtype-infoname std::string demangle(const char* name) { int status = -4; // some arbitrary value to eliminate the compiler warning std::unique_ptr res { abi::__cxa_demangle(name, nullptr, nullptr, &status), std::free }; return (status==0) ? res.get() : name ; } #else // does nothing if not g++ std::string demangle(const char* name) { return name; } #endif Error::Error(const string &message) : msg_(message), backtrace_(make_backtrace()) {} const string &Error::backtrace() const { return backtrace_; } const char* Error::what() const noexcept { return msg_.c_str(); } IOerror::IOerror(const string &message, const int error_code) : ExpectedError(message + std::strerror(error_code)), code_(error_code) {} int IOerror::code() { return code_; } Bug::Bug(const string &desc) : Error(desc) {} void handle_uncaught() { std::string err = std::strerror(errno); try { std::rethrow_exception(std::current_exception()); } catch (const std::exception &e) { log(TF_ERR) << "Unhandled " << demangle(typeid(e).name()) << ": " << e.what() << "." << flush << "errno = " << err << "." << flush << flush << "Backtrace:" << flush << make_backtrace() << flush #if not defined(DISABLE_EXCEPTION_CATCHING) << MSG_BUG << flush #endif ; } // We can expect to be killed by SIGABRT after this function returns. PidFileHolder::cleanup(); } SyntaxError::SyntaxError(const string filename, const std::ptrdiff_t offset, const string &input) { unsigned int line = 1; msg_ += filename + ":"; std::string::size_type line_start = 0; unsigned int i = 0; for (i = 0; i < offset; ++i) { if (input[i] == '\n') { ++line; line_start = i + 1; } } msg_ += std::to_string(line) + ": Invalid syntax:\n"; std::string::size_type line_end = input.find('\n', line_start) - line_start; msg_ += input.substr(line_start, line_end) + '\n'; msg_ += std::string(offset - line_start, ' ') + "^\n"; } ConfigError::ConfigError(const string &reason) : ExpectedError(reason) , reason_(reason) {} void ConfigError::set_filename(const string &filename) { msg_ = filename + ":\n" + msg_; } const string &ConfigError::filename() const { return filename_; } const string &ConfigError::reason() const { return reason_; } const char* ConfigError::what() const noexcept { return msg_.c_str(); } #ifdef USE_YAML ConfigError::ConfigError(const string &filename, const YAML::Mark &mark, const string &input, const string &msg) : reason_(msg) , filename_(filename) { msg_ = filename + ":"; // Another workaround for Ubuntu's libyaml-cpp0.5v5 if (mark.pos == -1 && mark.line == -1 && mark.column == -1) { msg_ += string(" ") + msg + "."; #ifdef HAVE_OLD_YAMLCPP msg_+= "\nYou have an ancient libyaml-cpp which can't give line numbers on errors. Please complain to your Linux distribution."; #endif } else { msg_ += std::to_string(mark.line + 1) + ":\n"; std::stringstream s(input); std::array line; for (int i = 0; i <= mark.line; i++) s.getline(&line[0], 1024); msg_ += line.data() + string("\n"); msg_ += string(static_cast(mark.column), ' ') + "^\n"; msg_ += msg + "."; } } YamlError::YamlError(const YAML::Mark &mark, const string &msg) : Error(msg), mark(mark) {} MissingEntry::MissingEntry(const string &entry) : YamlError(YAML::Mark::null_mark(), string("Missing `") + entry + "' entry.") {} #endif InvocationError::InvocationError(const string &message) : ExpectedError("Invalid command line: " + message) {} } thinkfan-1.3.1/src/error.h000066400000000000000000000064701417751172400154270ustar00rootroot00000000000000/******************************************************************** * error.h: Custom exceptions * (C) 2015, Victor Mataré * * this file is part of thinkfan. See thinkfan.c for further information. * * thinkfan is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * thinkfan 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. * * You should have received a copy of the GNU General Public License * along with thinkfan. If not, see . * * ******************************************************************/ #ifndef THINKFAN_ERROR_H_ #define THINKFAN_ERROR_H_ #include #include #include "message.h" #include "thinkfan.h" #ifdef USE_YAML #include #include #endif #ifndef MAX_BACKTRACE_DEPTH #define MAX_BACKTRACE_DEPTH 64 #endif namespace thinkfan { std::string demangle(const char* name); // Cf. http://stackoverflow.com/questions/281818/unmangling-the-result-of-stdtype-infoname template std::string type(const T &t) { return demangle(typeid(t).name()); } class Error : public std::exception { protected: string msg_; string backtrace_; public: Error(const string &message = ""); virtual const char* what() const noexcept override; const string &backtrace() const; }; class Bug : public Error { public: Bug(const string &desc = ""); }; class ExpectedError : public Error { using Error::Error; }; class IOerror : public ExpectedError { private: const int code_; public: IOerror(const string &message, const int error_code); int code(); }; class SensorLost : public ExpectedError { public: template SensorLost(const CauseT &cause) { msg_ = string("Lost sensor ") + cause.what(); } }; class SyntaxError : public ExpectedError { public: SyntaxError(const string filename, const std::ptrdiff_t offset, const string &input); }; #ifdef USE_YAML class YamlError : public Error { public: YamlError(const YAML::Mark &mark = YAML::Mark::null_mark(), const string &msg = ""); YAML::Mark mark; }; class MissingEntry : public YamlError { public: MissingEntry(const string &entry); }; #endif class ConfigError : public ExpectedError { public: ConfigError(const string &reason); void set_filename(const string &filename); const string &filename() const; const string &reason() const; virtual const char* what() const noexcept override; #ifdef USE_YAML ConfigError(const string &filename, const YAML::Mark &mark, const string &input, const string &msg); #endif private: const string reason_; const string filename_; }; class ParserOOM : public ExpectedError {}; class MixedLevelSpecs : public ExpectedError {}; class LimitLengthMismatch : public ExpectedError {}; class SystemError : public ExpectedError { public: SystemError(const string &reason) : ExpectedError(reason) {} }; class InvocationError : public ExpectedError { public: InvocationError(const string &message); }; void handle_uncaught(); } #endif /* THINKFAN_ERROR_H_ */ thinkfan-1.3.1/src/fans.cpp000066400000000000000000000164071417751172400155610ustar00rootroot00000000000000/******************************************************************** * drivers.cpp: Interface to the kernel drivers. * (C) 2015, Victor Mataré * * this file is part of thinkfan. See thinkfan.c for further information. * * thinkfan is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * thinkfan 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. * * You should have received a copy of the GNU General Public License * along with thinkfan. If not, see . * * ******************************************************************/ #include "fans.h" #include "error.h" #include "message.h" #include "config.h" #include #include #include #include #ifdef USE_NVML #include #endif namespace thinkfan { /*---------------------------------------------------------------------------- | FanDriver: Superclass of TpFanDriver and HwmonFanDriver. Can set the speed | | on its own since an implementation-specific string representation is | | provided by its subclasses. | ----------------------------------------------------------------------------*/ FanDriver::FanDriver(const std::string &path, const unsigned int watchdog_timeout) : path_(path), watchdog_(watchdog_timeout), depulse_(0) {} void FanDriver::set_speed(const string &level) { std::ofstream f_out(path_); if(!(f_out << level << std::flush)) { int err = errno; if (err == EPERM) throw SystemError(MSG_FAN_EPERM(path_)); else throw IOerror(MSG_FAN_CTRL(level, path_), err); } current_speed_ = level; } bool FanDriver::operator == (const FanDriver &other) const { return typeid(*this) == typeid(other) && this->path_ == other.path_ && this->depulse_ == other.depulse_ && this->watchdog_ == other.watchdog_; } const string &FanDriver::current_speed() const { return current_speed_; } /*---------------------------------------------------------------------------- | TpFanDriver: Driver for fan control via thinkpad_acpi, typically in | | /proc/acpi/ibm/fan. Supports fan watchdog and depulsing (an alleged remedy | | for noise oscillation with old & worn-out fans). | ----------------------------------------------------------------------------*/ TpFanDriver::TpFanDriver(const std::string &path) : FanDriver(path, 120) {} TpFanDriver::~TpFanDriver() noexcept(false) { std::ofstream f(path_); if (!(f.is_open() && f.good())) { log(TF_ERR) << MSG_FAN_RESET(path_) << strerror(errno) << flush; return; } if (!initial_state_.empty()) { log(TF_DBG) << path_ << ": Restoring initial state: " << initial_state_ << "." << flush; if (!(f << "level " << initial_state_ << std::flush)) log(TF_ERR) << MSG_FAN_RESET(path_) << strerror(errno) << flush; } } void TpFanDriver::set_watchdog(const unsigned int timeout) { watchdog_ = std::chrono::duration(timeout); } void TpFanDriver::set_depulse(float duration) { depulse_ = std::chrono::duration(duration); } void TpFanDriver::set_speed(const Level &level) { FanDriver::set_speed(level.str()); last_watchdog_ping_ = std::chrono::system_clock::now(); } void TpFanDriver::ping_watchdog_and_depulse(const Level &level) { if (depulse_ > std::chrono::milliseconds(0)) { FanDriver::set_speed("level disengaged"); std::this_thread::sleep_for(depulse_); set_speed(level); } else if (last_watchdog_ping_ + watchdog_ - sleeptime <= std::chrono::system_clock::now()) { log(TF_DBG) << "Watchdog ping" << flush; set_speed(level); } } void TpFanDriver::init() { bool ctrl_supported = false; std::fstream f(path_); if (!(f.is_open() && f.good())) throw IOerror(MSG_FAN_INIT(path_), errno); std::string line; line.resize(256); while (f.getline(&*line.begin(), 255)) { if (initial_state_.empty() && line.rfind("level:") != string::npos) { // remember initial level, restore it in d'tor string::size_type offs = line.find_last_of(" \t") + 1; if (offs != string::npos) { // Cut of at bogus \000 char that may occur before EOL initial_state_ = line.substr(offs, line.find_first_of('\000') - offs); } log(TF_DBG) << path_ << ": Saved initial state: " << initial_state_ << "." << flush; } else if (line.rfind("commands:") != std::string::npos && line.rfind("level ") != std::string::npos) { ctrl_supported = true; } } if (!ctrl_supported) throw SystemError(MSG_FAN_MODOPTS); if (initial_state_.empty()) throw SystemError(MSG_FAN_INIT(path_) + "Failed to read initial state."); f.close(); f.open(path_); if (!(f << "watchdog " << watchdog_.count() << std::flush)) throw IOerror(MSG_FAN_INIT(path_), errno); } /*---------------------------------------------------------------------------- | HwmonFanDriver: Driver for PWM fans, typically somewhere in sysfs. | ----------------------------------------------------------------------------*/ HwmonFanDriver::HwmonFanDriver(const std::string &path) : FanDriver(path, 0) {} HwmonFanDriver::~HwmonFanDriver() noexcept(false) { std::ofstream f(path_ + "_enable"); if (!(f.is_open() && f.good())) { log(TF_ERR) << MSG_FAN_RESET(path_) << strerror(errno) << flush; return; } if (!initial_state_.empty()) { log(TF_DBG) << path_ << ": Restoring initial state: " << initial_state_ << "." << flush; if (!(f << initial_state_ << std::flush)) log(TF_ERR) << MSG_FAN_RESET(path_) << strerror(errno) << flush; } } void HwmonFanDriver::init() { std::fstream f(path_ + "_enable"); if (!(f.is_open() && f.good())) throw IOerror(MSG_FAN_INIT(path_), errno); if (initial_state_.empty()) { std::string line; line.resize(64); if (!f.getline(&*line.begin(), 63)) throw IOerror(MSG_FAN_INIT(path_), errno); initial_state_ = line; log(TF_DBG) << path_ << ": Saved initial state: " << initial_state_ << "." << flush; } if (!(f << "1" << std::flush)) throw IOerror(MSG_FAN_INIT(path_), errno); } void HwmonFanDriver::set_speed(const Level &level) { try { FanDriver::set_speed(std::to_string(level.num())); } catch (IOerror &e) { if (e.code() == EINVAL) { // This happens when the hwmon kernel driver is reset to automatic control // e.g. after the system has woken up from suspend. // In that case, we need to re-initialize and try once more. init(); FanDriver::set_speed(std::to_string(level.num())); log(TF_WRN) << path_ << ": WARNING: Userspace fan control had to be automatically re-initialized." << flush; #if defined(HAVE_SYSTEMD) log(TF_WRN) << "This should have been taken care of when enabling the thinkfan systemd service." << flush << "If thinkfan.service is enabled, the following services should also have be enabled as a dependency:" << flush << "thinkfan-hibernate.service, thinkfan-hybrid-suspend.service and thinkfan-suspend.service" << flush; #else log(TF_WRN) << "Please arrange for a SIGUSR2 to be sent to thinkfan after resuming from suspend." << flush; #endif } else { throw; } } } } thinkfan-1.3.1/src/fans.h000066400000000000000000000044131417751172400152200ustar00rootroot00000000000000#pragma once /******************************************************************** * config.h: Config data structures and consistency checking. * (C) 2015, Victor Mataré * * this file is part of thinkfan. See thinkfan.c for further information. * * thinkfan is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * thinkfan 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. * * You should have received a copy of the GNU General Public License * along with thinkfan. If not, see . * * ******************************************************************/ #include #include "thinkfan.h" namespace thinkfan { class Level; class FanDriver { protected: string path_; string initial_state_; string current_speed_; seconds watchdog_; secondsf depulse_; std::chrono::system_clock::time_point last_watchdog_ping_; FanDriver(const string &path, const unsigned int watchdog_timeout = 120); public: FanDriver() : watchdog_(0) {} bool is_default() { return path_.length() == 0; } virtual ~FanDriver() noexcept(false) {} virtual void init() {} virtual void set_speed(const string &level); virtual void set_speed(const Level &level) = 0; const string ¤t_speed() const; virtual void ping_watchdog_and_depulse(const Level &) {} bool operator == (const FanDriver &other) const; }; class TpFanDriver : public FanDriver { public: TpFanDriver(const string &path); virtual ~TpFanDriver() noexcept(false) override; void set_watchdog(const unsigned int timeout); void set_depulse(float duration); virtual void init() override; virtual void set_speed(const Level &level) override; virtual void ping_watchdog_and_depulse(const Level &level) override; }; class HwmonFanDriver : public FanDriver { public: HwmonFanDriver(const string &path); virtual ~HwmonFanDriver() noexcept(false) override; virtual void init() override; virtual void set_speed(const Level &level) override; }; } thinkfan-1.3.1/src/message.cpp000066400000000000000000000102571417751172400162530ustar00rootroot00000000000000/******************************************************************** * message.cpp: Logging and error management. * (C) 2015, Victor Mataré * * this file is part of thinkfan. See thinkfan.c for further information. * * thinkfan is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * thinkfan 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. * * You should have received a copy of the GNU General Public License * along with thinkfan. If not, see . * * ******************************************************************/ #include "error.h" #include "thinkfan.h" #include "message.h" #include "config.h" #include #include namespace thinkfan { unique_ptr Logger::instance_(nullptr); LogLevel &operator--(LogLevel &l) { if (l == TF_DBG) l = TF_INF; else if (l == TF_INF) l = TF_NFY; else if (l == TF_NFY) l = TF_WRN; else l = TF_ERR; return l; } LogLevel &operator++(LogLevel &l) { if (l == TF_ERR) l = TF_WRN; else if (l == TF_WRN) l = TF_NFY; else if (l == TF_NFY) l = TF_INF; else if (l == TF_INF) l = TF_DBG; return l; } Logger::Logger() : syslog_(false), log_lvl_(DEFAULT_LOG_LVL), msg_lvl_(DEFAULT_LOG_LVL) {} Logger &Logger::instance() { if (!instance_) instance_ = unique_ptr(new Logger()); return *instance_; } LogLevel &Logger::log_lvl() { return log_lvl_; } Logger &flush(Logger &l) { return l.flush(); } Logger &log(LogLevel lvl) { Logger::instance().level(lvl); return Logger::instance(); } Logger::~Logger() { flush(); if (syslog_) closelog(); } void Logger::enable_syslog() { #ifndef DISABLE_SYSLOG openlog("thinkfan", LOG_CONS, LOG_USER); syslog_ = true; #endif //DISABLE_SYSLOG } Logger &Logger::flush() { if (msg_pfx_.length() == 0) return *this; if (msg_lvl_ <= log_lvl_) { if (syslog_) { #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wformat-security" // I think we can safely do this because thinkfan doesn't receive // any data from unprivileged processes. syslog(msg_lvl_, msg_pfx_.c_str()); #pragma GCC diagnostic pop } else { std::cerr << msg_pfx_ << std::endl; } } msg_pfx_ = ""; return *this; } Logger &Logger::level(const LogLevel &lvl) { flush(); if (!syslog_ && msg_lvl_ != lvl && lvl >= log_lvl_ && msg_lvl_ >= log_lvl_) msg_pfx_ = "\n"; else msg_pfx_ = ""; if (lvl == TF_WRN) msg_pfx_ += "WARNING: "; else if (lvl == TF_ERR) msg_pfx_ += "ERROR: "; this->msg_lvl_ = lvl; return *this; } Logger &Logger::operator<<( const std::string &msg) { msg_pfx_ += msg; return *this; } Logger &Logger::operator<< (const int i) { msg_pfx_ += std::to_string(i); return *this; } Logger &Logger::operator<< (const unsigned int i) { msg_pfx_ += std::to_string(i); return *this; } Logger &Logger::operator<< (const float &i) { msg_pfx_ += std::to_string(i); return *this; } Logger &Logger::operator<< (const char *msg) { msg_pfx_ += msg; return *this; } Logger &Logger::operator<< (char *msg) { msg_pfx_ += msg; return *this; } Logger &Logger::operator<< (Logger & (*pf_flush)(Logger &)) { return pf_flush(*this); } Logger &Logger::operator<< (const TemperatureState &ts) { msg_pfx_ += "Temperatures(bias): "; vector::const_iterator bias_it; vector::const_iterator temp_it; for (temp_it = ts.temps().cbegin(), bias_it = ts.biases().cbegin(); temp_it != ts.temps().cend() && bias_it != ts.biases().cend(); ++temp_it, ++bias_it) msg_pfx_ += std::to_string(*temp_it) + "(" + std::to_string(int(*bias_it)) + "), "; msg_pfx_.pop_back(); msg_pfx_.pop_back(); return *this; } Logger &Logger::operator<< (const vector> &fan_configs) { msg_pfx_ += "Fans: "; for (const unique_ptr &fan_cf : fan_configs) msg_pfx_ += fan_cf->fan()->current_speed() + ", "; msg_pfx_.pop_back(); msg_pfx_.pop_back(); return *this; } } thinkfan-1.3.1/src/message.h000066400000000000000000000226171417751172400157230ustar00rootroot00000000000000/******************************************************************** * message.h: Logging and error management. * (C) 2015, Victor Mataré * * this file is part of thinkfan. See thinkfan.c for further information. * * thinkfan is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * thinkfan 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. * * You should have received a copy of the GNU General Public License * along with thinkfan. If not, see . * * ******************************************************************/ #ifndef MESSAGE_H #define MESSAGE_H #include #include #include #include #include "thinkfan.h" namespace thinkfan { enum LogLevel { TF_ERR = LOG_ERR, TF_WRN = LOG_WARNING, TF_NFY = LOG_NOTICE, TF_INF = LOG_INFO, TF_DBG = LOG_DEBUG }; #ifdef DEBUG #define DEFAULT_LOG_LVL TF_DBG #else #define DEFAULT_LOG_LVL TF_NFY #endif LogLevel &operator--(LogLevel &l); LogLevel &operator++(LogLevel &l); class ExpectedError; class FanConfig; class Logger { private: Logger(); static unique_ptr instance_; public: ~Logger(); void enable_syslog(); Logger &level(const LogLevel &lvl); Logger &flush(); static Logger &instance(); LogLevel &log_lvl(); Logger &operator<< (const std::string &msg); Logger &operator<< (const unsigned int i); Logger &operator<< (const int i); Logger &operator<< (const float &d); Logger &operator<< (Logger & (*pf_flush)(Logger &)); Logger &operator<< (const char *msg); Logger &operator<< (char *msg); Logger &operator<< (const TemperatureState &); Logger &operator<< (const vector> &); template Logger &operator<< (const ListT &l) { msg_pfx_ += "("; for (auto elem : l) { msg_pfx_ += std::to_string(elem) + ", "; } msg_pfx_.pop_back(); msg_pfx_.pop_back(); msg_pfx_ += ")"; return *this; } private: bool syslog_; LogLevel log_lvl_; LogLevel msg_lvl_; std::string msg_pfx_; std::exception_ptr exception_; }; Logger &flush(Logger &l); Logger &log(LogLevel lvl); template void error(const ArgTs &... args) { if (chk_sanity) throw ErrT(args...); else log(TF_ERR) << ErrT(args...).what() << flush; } } #ifdef USE_ATASMART #define DND_DISK_HELP \ "\n -d Don't read S.M.A.R.T. temperature from sleeping disks" #else #define DND_DISK_HELP "" #endif #define MSG_TITLE "thinkfan " VERSION ": A minimalist fan control program" #define MSG_USAGE \ "Usage: thinkfan [-hnqDd [-b BIAS] [-c CONFIG] [-s SECONDS] [-p [SECONDS]]]" \ "\n -h This help message" \ "\n -s Maximum cycle time in seconds (Integer. Default: 5)" \ "\n -b Floating point number (-10 to 30) to control rising temperature" \ "\n exaggeration (see README). Default: 5.0" \ "\n -c Load different configuration file (default: /etc/thinkfan.conf)" \ "\n -n Do not become a daemon and log to terminal instead of syslog" \ "\n -q Be more quiet. Can be specified up to three times so that only errors" \ "\n are logged." \ "\n -v Enable verbose logging (e.g. log temperatures continuously)." \ "\n -p Use the pulsing-fan workaround (for worn out fans). Takes an optional" \ "\n floating-point argument (0 ~ 10s) as depulsing duration. Default 0.5s." \ DND_DISK_HELP \ "\n -D DANGEROUS mode: Disable all sanity checks. May result in undefined" \ "\n behaviour!\n" #define MSG_FILE_HDR(file, line_count, line) file + ":" + std::to_string(line_count) + ":" + line #define MSG_RELOAD_CONF "Received SIGHUP: reloading config..." #define MSG_SANITY "Sanity checks are on. Exiting." #define MSG_INSANITY "Sanity checks are off. Continuing." #define MSG_CONFIG(path) \ "Config as read from " + path + ":\nFan level\tLow\tHigh" #define MSG_CONF_ITEM(level, low, high) " " + std::to_string(level) + "\t\t" + std::to_string(low) + "\t" + std::to_string(high) #define MSG_TERM "Cleaning up and resetting fan control." #define MSG_DEPULSE(delay, time) "Disengaging the fan controller for " \ << time << " seconds every " << delay << " seconds" #define MSG_SYSFS_SAFE "Using safe but wasteful way of setting PWM value. Check README to know more." #define MSG_RUNNING PID_FILE " already exists. Either thinkfan is " \ "already running, or it was killed by SIGKILL. If you're sure thinkfan" \ " is not running, delete " PID_FILE " manually." #define MSG_SENSOR_LOST "A sensor has vanished! Exiting since there's no " \ "safe way of handling this." #define TRACKER_URL "https://github.com/vmatare/thinkfan/issues" #define MSG_BUG "This is probably a bug. Please consider reporting this at " TRACKER_URL ". Thanks." #define MSG_NO_SENSOR "No sensors in config file." #define MSG_T_GET(file) string(__func__) + ": Failed to read temperature(s) from " + file + ": " #define MSG_T_INVALID(s, d) s + ": Invalid temperature: " + std::to_string(d) #define MSG_SENSOR_INIT(file) string(__func__) + ": Initializing sensor in " + file + ": " #define MSG_HWMON_NOT_FOUND "Could not find a hwmon with this name" #define MSG_MULTIPLE_HWMONS_FOUND "Found multiple hwmons with this name: " #define MSG_FAN_MODOPTS \ "Module thinkpad_acpi doesn't seem to support fan_control" #define MSG_FAN_CTRL(str, fan) string(__func__) + ": Writing \"" + str + "\" to " + fan + ": " #define MSG_FAN_INIT(fan) string(__func__) + ": Initializing fan control in " + fan + ": " #define MSG_FAN_RESET(fan) string(__func__) + ": Resetting fan control in " + fan + ": " #define MSG_FAN_EPERM(fan) string(__func__) + ": No permission to write to " + fan \ + ". Thinkfan needs to be run as root!" #define MSG_OPT_S_15(t) std::to_string(t) + " seconds of not realizing "\ "rising temperatures may be dangerous!" #define MSG_OPT_S_1(t) "A sleeptime of " + std::to_string(t) + " seconds doesn't make much " \ "sense." #define MSG_OPT_S "option -s requires an int argument!" #define MSG_OPT_S_INVAL(x) string("invalid argument to option -s: ") + x #define MSG_OPT_B "bias must be between -10 and 30!" #define MSG_OPT_B_NOARG "option -b requires an argument!" #define MSG_OPT_B_INVAL(x) string("invalid argument to option -b: ") + x #define MSG_OPT_P(x) string("invalid argument to option -p: ") + x #define MSG_CONF_DEFAULT_FAN "Using default fan control in " DEFAULT_FAN "." #define MSG_CONF_NOBIAS(t) "You're using simple temperature limits" \ " without correction values, and your fan will only start at " << t << " °C. This can " \ "be dangerous for your hard drive." #define MSG_CONF_NUM_TEMPS(n, i) "You have " << std::to_string(n) << " sensors but your temper" \ "ature limits only have " << std::to_string(i) << " entries. Excess sensors will be ignored." #define MSG_CONF_SENSOR_DEPRECATED "The `sensor' keyword is deprecated. " \ "Please use the `hwmon' or `tp_thermal' keywords instead!" #define MSG_CONF_FAN_DEPRECATED "Guessing the fan type from the path" \ " is deprecated. Please use `tp_fan' or `pwm_fan' to make things clear." #define MSG_CONF_RELOAD_ERR "Error reloading config. Keeping old one." #define MSG_CONF_NOFAN "Could not find any fan speed settings in" \ " the config file. Please read AND UNDERSTAND the documentation!" #define MSG_CONF_LOWHIGH "Your LOWER limit is not lesser than your " \ "UPPER limit. That doesn't make sense." #define MSG_CONF_OVERLAP "LOWER limit doesn't overlap with previous UPPER limit" #define MSG_CONF_FAN "Thinkfan can't use more than one fan" #define MSG_CONF_LVLORDER "Fan levels are not ordered correctly" #define MSG_CONF_PARSE "Syntax error" #define MSG_CONF_LVL0 "The LOWER limit of the first fan level cannot con" \ "tain any values greater than 0!" #define MSG_CONF_LVLFORMAT(s) "Unrecognized fan level string: " + s #define MSG_CONF_LCOUNT "The number of limits must either be 1 or equal to the" \ " number of temperatures" #define MSG_CONF_LONG_LIMIT "You have configured more temperature limits " \ "than sensors. That doesn't make sense" #define MSG_CONF_LIMITLEN "Inconsistent limit length" #define MSG_CONF_CORRECTION_LEN(path, clen, ntemp) string("Sensor ") + path + " has " \ + std::to_string(ntemp) + " temperatures," \ " but you have " + std::to_string(clen) + " correction values for it." #define MSG_CONF_ATASMART_UNSUPP "S.M.A.R.T support is not compiled in. Recompile with -DUSE_ATASMART or " \ "contact your distribution's package maintainer." #define MSG_CONF_NVML_UNSUPP "NVML support is not compiled in. Recompile with -DUSE_NVML or " \ "contact your distribution's package maintainer." #define MSG_TEMP_COUNT(t_conf, t_found) "Your config requires at least " << t_conf << " temperatures, " \ "but only " << t_found << " temperatures were found." #define MSG_CONF_MAXLVL(n) "You're using a PWM fan, but your highest fan level is only " + std::to_string(n) \ + ". Enable DANGEROUS mode if you're really sure you never need to max out your fan" #define MSG_CONF_TP_LVL7(n, max) "Your highest fan level is " + std::to_string(n) + \ ", but fan levels greater than " + std::to_string(max) + " are not supported by thinkpad_acpi" #define MSG_CONF_MISSING_LOWER_LIMIT "You must specify a lower limit on all but the first fan level" #define MSG_CONF_MISSING_UPPER_LIMIT "You must specify an upper limit on all but the last fan level" #endif thinkfan-1.3.1/src/parser.cpp000066400000000000000000000231461417751172400161240ustar00rootroot00000000000000/******************************************************************** * parser.cpp: Recursive descent parser for the config. * (C) 2015, Victor Mataré * * this file is part of thinkfan. See thinkfan.c for further information. * * thinkfan is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * thinkfan 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. * * You should have received a copy of the GNU General Public License * along with thinkfan. If not, see . * * ******************************************************************/ #include "error.h" #include "parser.h" #include "config.h" #include namespace thinkfan { using namespace std; const char *ErrorTracker::max_addr_ = nullptr; static RegexParser separator_parser("^([[:space:]]*,)|^([[:space:]]+)", 0); static CommentParser comment_parser; static RegexParser space_parser("^[[:space:]]+", 0, true); static RegexParser blank_parser("^[[:blank:]]+", 0, false); RegexParser::RegexParser(const string expr, const unsigned int data_idx, bool match_nl) : data_idx_(data_idx), re_str(expr) { this->expr_ = new regex_t; if (regcomp(this->expr_, re_str.c_str(), REG_EXTENDED | (match_nl ? 0 : REG_NEWLINE))) { throw Bug("RegexParser: Invalid regular expression"); } } RegexParser::~RegexParser() { regfree(expr_); delete expr_; } string *RegexParser::_parse(const char *&input) { regmatch_t matches[data_idx_ + 1]; string *rv = nullptr; int err; if (!(err = regexec(this->expr_, input, this->data_idx_ + 1, matches, 0))) { int so = matches[data_idx_].rm_so; int eo = matches[data_idx_].rm_eo; if (so != -1 && matches[0].rm_so == 0) { rv = new string(input, so, eo - so); input += matches->rm_eo; } } else if (err == REG_ESPACE) { delete rv; throw ParserOOM(); } return rv; } int *IntParser::_parse(const char *&input) { char *end; long l = strtol(input, &end, 0); if (end == input || l < numeric_limits::min() || l > numeric_limits::max()) return nullptr; input = end; return new int(static_cast(l)); } CommentParser::CommentParser() : comment_parser_("^[[:space:]]*#(.*)$", 1) {} string *CommentParser::_parse(const char *&input) { space_parser.match(input); string *rv = nullptr; string *tmp; while ((tmp = comment_parser_.parse(input))) { if (!rv) rv = tmp; else { *rv += *tmp; delete tmp; } space_parser.match(input); } return rv; } KeywordParser::KeywordParser(const string keyword) : RegexParser("^[[:space:]]*" + keyword + "[[:space:]]+([^[:space:]]+|\"[^\"]+\")", 1) {} FanDriver *FanParser::_parse(const char *&input) { FanDriver *fan = nullptr; unique_ptr path; if ((path = unique_ptr(KeywordParser("fan").parse(input)))) throw ConfigError(MSG_CONF_FAN_DEPRECATED); else if ((path = unique_ptr(KeywordParser("tp_fan").parse(input)))) fan = new TpFanDriver(*path); else if ((path = unique_ptr(KeywordParser("pwm_fan").parse(input)))) fan = new HwmonFanDriver(*path); return fan; } SensorDriver *SensorParser::_parse(const char *&input) { SensorDriver *sensor = nullptr; unique_ptr path; if ((path = unique_ptr(KeywordParser("sensor").parse(input)))) throw ConfigError(MSG_CONF_SENSOR_DEPRECATED); else if ((path = unique_ptr(KeywordParser("tp_thermal").parse(input)))) sensor = new TpSensorDriver(*path, false); else if ((path = unique_ptr(KeywordParser("hwmon").parse(input)))) sensor = new HwmonSensorDriver(*path, false); else if ((path = unique_ptr(KeywordParser("atasmart").parse(input)))) { #ifdef USE_ATASMART sensor = new AtasmartSensorDriver(*path, false); #else error(MSG_CONF_ATASMART_UNSUPP); #endif /* USE_ATASMART */ } else if ((path = unique_ptr(KeywordParser("nv_thermal").parse(input)))) { #ifdef USE_NVML sensor = new NvmlSensorDriver(*path, false); #else error(MSG_CONF_NVML_UNSUPP); #endif /* USE_NVML */ } if (sensor) { blank_parser.match(input); unique_ptr> correction(TupleParser().parse(input)); if (correction) sensor->set_correction(*correction); } return sensor; } IntListParser::IntListParser(bool allow_dot) : dot_parser_("^\\."), allow_dot_(allow_dot) {} vector *IntListParser::_parse(const char *&input) { unique_ptr> rv(new vector()); unique_ptr dot; unique_ptr i; do { dot.reset(nullptr); if ( (void)i.reset(int_parser_.parse(input)), i) rv->push_back(*i); else if (allow_dot_ && ( (void)dot.reset(dot_parser_.parse(input)), dot)) rv->push_back(numeric_limits::max()); else break; if (!(separator_parser.match(input) || comment_parser.match(input))) break; comment_parser.match(input); } while(i || dot); if (rv->size() > 0) return rv.release(); return nullptr; } EnclosureParser::EnclosureParser(initializer_list bracket_pairs, bool nl) : brackets_(bracket_pairs), nl_(nl) { if (bracket_pairs.size() < 2 || bracket_pairs.size() % 2 != 0) throw Bug("EnclosureParser: Unbalanced bracket definition"); } string *EnclosureParser::_parse(const char *&input) { blank_parser.match(input); vector::const_iterator it = brackets_.begin(); unique_ptr rv; do { string re_pfx("^"); if (*it == "(" || *it == "{") re_pfx += "\\"; RegexParser re_o(re_pfx + *it++); rv.reset(re_o.parse(input)); if (rv) { closing_ = re_pfx + *it; content_ = "^[^" + *it + "]*"; } ++it; } while (!rv && it != brackets_.end()); return rv.release(); } bool EnclosureParser::open(const char *&input) { return match(input); } bool EnclosureParser::close(const char *&input) { return RegexParser(closing_).match(input); } string *EnclosureParser::content(const char *&input) { return RegexParser(content_, 0, nl_).parse(input); } BracketParser::BracketParser() : EnclosureParser({"(", ")", "{", "}"}) {} vector *TupleParser::_parse(const char *&input) { if (!bracket_parser_.open(input)) return nullptr; unique_ptr> rv(int_list_parser_.parse(input)); if (bracket_parser_.close(input)) return rv.release(); else return nullptr; } SimpleLevel *SimpleLevelParser::_parse(const char *&input) { if (!bracket_parser_.open(input)) return nullptr; unique_ptr> ints; comment_parser.match(input); EnclosureParser quot({"\"", "\""}); if (quot.open(input)) { unique_ptr lvl_str(quot.content(input)); if (quot.close(input) && lvl_str && (comment_parser.match(input) || separator_parser.match(input)) ) { comment_parser.match(input); ints.reset(IntListParser().parse(input)); if (ints && ints->size() == 2 && bracket_parser_.close(input)) return new SimpleLevel(*lvl_str, (*ints)[0], (*ints)[1]); } } else { ints.reset(IntListParser().parse(input)); if (ints && ints->size() == 3 && bracket_parser_.close(input)) return new SimpleLevel((*ints)[0], (*ints)[1], (*ints)[2]); } return nullptr; } ComplexLevel *ComplexLevelParser::_parse(const char *&input) { unique_ptr lvl_str; unique_ptr> lower_lim, upper_lim; unique_ptr lvl_int; if (!bracket_parser_.open(input)) return nullptr; comment_parser.match(input); space_parser.match(input); EnclosureParser quot({"\"", "\""}); if (quot.open(input)) { lvl_str.reset(quot.content(input)); if (!quot.close(input)) return nullptr; } else if (!(lvl_int = unique_ptr(IntParser().parse(input)))) return nullptr; TupleParser tp(true); RegexParser sep_parser("^[[:space:]]+|^[[:space:]]*,?[[:space:]]*", 0, true); comment_parser.match(input); sep_parser.match(input); comment_parser.match(input); lower_lim = unique_ptr>(tp.parse(input)); comment_parser.match(input); sep_parser.match(input); comment_parser.match(input); upper_lim = unique_ptr>(tp.parse(input)); space_parser.match(input); comment_parser.match(input); if (!(lower_lim && upper_lim)) return nullptr; if (!bracket_parser_.close(input)) return nullptr; if (lvl_str) return new ComplexLevel(*lvl_str, *lower_lim, *upper_lim); else if (lvl_int) return new ComplexLevel(*lvl_int, *lower_lim, *upper_lim); else return nullptr; } ConfigParser::ConfigParser() : parser_fan(), parser_sensor() {} Config *ConfigParser::_parse(const char *&input) { // Use smart pointers here since we may cause an exception (rv->add_*()...) unique_ptr rv(new Config()); unique_ptr fan_cfg(new StepwiseMapping()); bool some_match = false; do { some_match = comment_parser.match(input) || space_parser.match(input); unique_ptr fan { parser_fan.parse(input) }; if (fan) { fan_cfg->set_fan(std::move(fan)); some_match = true; } unique_ptr sensor { parser_sensor.parse(input) }; if (sensor) { rv->add_sensor(std::move(sensor)); some_match = true; } unique_ptr simple_lvl { parser_simple_lvl.parse(input) }; if (simple_lvl) { fan_cfg->add_level(std::move(simple_lvl)); some_match = true; } unique_ptr complex_lvl { parser_complex_lvl.parse(input) }; if (complex_lvl) { fan_cfg->add_level(std::move(complex_lvl)); some_match = true; } } while(*input != 0 && some_match); rv->add_fan_config(std::move(fan_cfg)); if (*input != 0 && !some_match) return nullptr; return rv.release(); } } thinkfan-1.3.1/src/parser.h000066400000000000000000000107561417751172400155740ustar00rootroot00000000000000/******************************************************************** * parser.h: Recursive descent parser for the config. * (C) 2015, Victor Mataré * * this file is part of thinkfan. See thinkfan.c for further information. * * thinkfan is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * thinkfan 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. * * You should have received a copy of the GNU General Public License * along with thinkfan. If not, see . * * ******************************************************************/ #ifndef THINKFAN_PARSER_H_ #define THINKFAN_PARSER_H_ #include #include #include #include #include "sensors.h" #include "fans.h" namespace thinkfan { class SimpleLevel; class ComplexLevel; class Config; static const string tpacpi_path = "/proc/acpi/ibm"; class ErrorTracker { protected: static const char *max_addr_; }; template class Parser : ErrorTracker { public: Parser() {} virtual ~Parser() = default; const char *get_max_addr() const { return max_addr_; } ResultT *parse(const char *&input) { const char *start = input; ResultT *rv = _parse(input); if (input > max_addr_) max_addr_ = input; if (!rv) input = start; return rv; } bool match(const char *&input) { ResultT *result = parse(input); if (result) { delete result; return true; } return false; } protected: virtual ResultT *_parse(const char *&input) = 0; }; class RegexParser : public Parser { private: regex_t *expr_; unsigned int data_idx_; string re_str; public: RegexParser(const string expr, const unsigned int data_idx = 0, bool match_nl = false); virtual ~RegexParser(); virtual string *_parse(const char *&input) override; }; class IntParser : public Parser { public: virtual int *_parse(const char *&input) override; }; class CommentParser : public Parser { private: RegexParser comment_parser_; public: CommentParser(); virtual string *_parse(const char *&input) override; }; class KeywordParser : public RegexParser { public: KeywordParser(const std::string keyword); }; class FanParser : public Parser { public: virtual FanDriver *_parse(const char *&input) override; }; class IntListParser : public Parser> { private: IntParser int_parser_; RegexParser dot_parser_; bool allow_dot_; public: IntListParser(bool allow_dot = false); virtual vector *_parse(const char *&input) override; }; class EnclosureParser : public Parser { public: EnclosureParser(std::initializer_list bracket_pairs, bool nl = true); virtual string *_parse(const char *&input) override; bool open(const char *&input); bool close(const char *&input); string *content(const char *&input); private: string closing_; string content_; vector brackets_; bool nl_; }; class BracketParser : public EnclosureParser { public: BracketParser(); }; class SensorParser : public Parser { public: virtual SensorDriver *_parse(const char *&input) override; private: BracketParser bracket_parser_; }; class TupleParser : public Parser> { public: TupleParser(bool allow_dot = false) : int_list_parser_(allow_dot) {} virtual vector *_parse(const char *&input) override; private: BracketParser bracket_parser_; IntListParser int_list_parser_; }; class SimpleLevelParser : public Parser { public: SimpleLevelParser() {} virtual SimpleLevel *_parse(const char *&input) override; private: BracketParser bracket_parser_; }; class ComplexLevelParser : public Parser { public: ComplexLevelParser() {} virtual ComplexLevel *_parse(const char *&input) override; private: BracketParser bracket_parser_; }; class ConfigParser : public Parser { private: FanParser parser_fan; SensorParser parser_sensor; SimpleLevelParser parser_simple_lvl; ComplexLevelParser parser_complex_lvl; public: ConfigParser(); Config *parse_config(const char *&input) { return parse(input); } protected: virtual Config *_parse(const char *&input) override; }; } /* namespace thinkfan */ #endif /* THINKFAN_PARSER_H_ */ thinkfan-1.3.1/src/sensors.cpp000066400000000000000000000245011417751172400163200ustar00rootroot00000000000000/******************************************************************** * drivers.cpp: Interface to the kernel drivers. * (C) 2015, Victor Mataré * * this file is part of thinkfan. See thinkfan.c for further information. * * thinkfan is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * thinkfan 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. * * You should have received a copy of the GNU General Public License * along with thinkfan. If not, see . * * ******************************************************************/ #include "sensors.h" #include "error.h" #include "message.h" #include "config.h" #include #include #include #include #ifdef USE_NVML #include #endif namespace thinkfan { /*---------------------------------------------------------------------------- | SensorDriver: The superclass of all hardware-specific sensor drivers | ----------------------------------------------------------------------------*/ SensorDriver::SensorDriver(std::string path, bool optional, vector correction) : path_(path), correction_(correction), num_temps_(0), optional_(optional) { std::ifstream f(path_); if (!(f.is_open() && f.good())) throw IOerror(path_ + ": ", errno); } SensorDriver::SensorDriver(bool optional) : num_temps_(0), optional_(optional) {} SensorDriver::~SensorDriver() noexcept(false) {} void SensorDriver::set_correction(const vector &correction) { correction_ = correction; check_correction_length(); } void SensorDriver::set_num_temps(unsigned int n) { num_temps_ = n; if (correction_.empty()) correction_.resize(num_temps_, 0); else check_correction_length(); } bool SensorDriver::operator == (const SensorDriver &other) const { return typeid(*this) == typeid(other) && this->correction_ == other.correction_ && this->path_ == other.path_; } void SensorDriver::check_correction_length() { if (correction_.size() > num_temps()) throw ConfigError(MSG_CONF_CORRECTION_LEN(path_, correction_.size(), num_temps())); else if (correction_.size() < num_temps_) log(TF_WRN) << MSG_CONF_CORRECTION_LEN(path_, correction_.size(), num_temps()) << flush; } void SensorDriver::set_optional(bool o) { optional_ = o; } bool SensorDriver::optional() const { return optional_; } const string &SensorDriver::path() const { return path_; } /*---------------------------------------------------------------------------- | HwmonSensorDriver: A driver for sensors provided by other kernel drivers, | | typically somewhere in sysfs. | ----------------------------------------------------------------------------*/ HwmonSensorDriver::HwmonSensorDriver(std::string path, bool optional, vector correction) : SensorDriver(path, optional, correction) { set_num_temps(1); } void HwmonSensorDriver::read_temps_(TemperatureState &global_temps) const { std::ifstream f(path_); if (!(f.is_open() && f.good())) throw IOerror(MSG_T_GET(path_), errno); int tmp; if (!(f >> tmp)) throw IOerror(MSG_T_GET(path_), errno); global_temps.add_temp(tmp/1000 + correction_[0]); } /*---------------------------------------------------------------------------- | TpSensorDriver: A driver for sensors provided by thinkpad_acpi, typically | | in /proc/acpi/ibm/thermal. | ----------------------------------------------------------------------------*/ const string TpSensorDriver::skip_prefix_("temperatures:"); TpSensorDriver::TpSensorDriver(std::string path, bool optional, const vector &temp_indices, vector correction) : SensorDriver(path, optional, correction) { std::ifstream f(path_); if (!(f.is_open() && f.good())) throw IOerror(MSG_SENSOR_INIT(path_), errno); int tmp; unsigned int count = 0; string skip; skip.resize(skip_prefix_.size()); if (!f.get(&*skip.begin(), static_cast(skip_prefix_.size() + 1))) throw IOerror(MSG_SENSOR_INIT(path_), errno); if (skip == skip_prefix_) skip_bytes_ = f.tellg(); else throw SystemError(path_ + ": Unknown file format."); while (!(f.eof() || f.fail())) { f >> tmp; if (f.bad()) throw IOerror(MSG_T_GET(path_), errno); if (!f.fail()) ++count; } if (temp_indices.size() > 0) { if (temp_indices.size() > count) throw ConfigError( "Config specifies " + std::to_string(temp_indices.size()) + " temperature inputs in " + path + ", but there are only " + std::to_string(count) + "." ); set_num_temps(static_cast(temp_indices.size())); in_use_ = vector(count, false); for (unsigned int i : temp_indices) in_use_[i] = true; } else { in_use_ = vector(count, true); set_num_temps(count); } } TpSensorDriver::TpSensorDriver(std::string path, bool optional, vector correction) : TpSensorDriver(path, optional, {}, correction) {} void TpSensorDriver::read_temps_(TemperatureState &global_temps) const { std::ifstream f(path_); if (!(f.is_open() && f.good())) throw IOerror(MSG_T_GET(path_), errno); f.seekg(skip_bytes_); if (f.fail()) throw IOerror(MSG_T_GET(path_), errno); unsigned int tidx = 0; unsigned int cidx = 0; int tmp; while (!(f.eof() || f.fail())) { f >> tmp; if (f.bad()) throw IOerror(MSG_T_GET(path_), errno); if (!f.fail() && in_use_[tidx++]) global_temps.add_temp(tmp + correction_[cidx++]); } } #ifdef USE_ATASMART /*---------------------------------------------------------------------------- | AtssmartSensorDriver: Reads temperatures from hard disks using S.M.A.R.T. | | via device files like /dev/sda. | ----------------------------------------------------------------------------*/ AtasmartSensorDriver::AtasmartSensorDriver(string device_path, bool optional, vector correction) : SensorDriver(device_path, optional, correction) { if (sk_disk_open(device_path.c_str(), &disk_) < 0) { string msg = std::strerror(errno); throw SystemError("sk_disk_open(" + device_path + "): " + msg); } set_num_temps(1); } AtasmartSensorDriver::~AtasmartSensorDriver() { sk_disk_free(disk_); } void AtasmartSensorDriver::read_temps_(TemperatureState &global_temps) const { SkBool disk_sleeping = false; if (unlikely(dnd_disk && (sk_disk_check_sleep_mode(disk_, &disk_sleeping) < 0))) { string msg = strerror(errno); throw SystemError("sk_disk_check_sleep_mode(" + path_ + "): " + msg); } if (unlikely(disk_sleeping)) { global_temps.add_temp(0); } else { uint64_t mKelvin; float tmp; if (unlikely(sk_disk_smart_read_data(disk_) < 0)) { string msg = strerror(errno); throw SystemError("sk_disk_smart_read_data(" + path_ + "): " + msg); } if (unlikely(sk_disk_smart_get_temperature(disk_, &mKelvin)) < 0) { string msg = strerror(errno); throw SystemError("sk_disk_smart_get_temperature(" + path_ + "): " + msg); } tmp = mKelvin / 1000.0f; tmp -= 273.15f; if (unlikely(tmp > std::numeric_limits::max() || tmp < std::numeric_limits::min())) { throw SystemError(MSG_T_GET(path_) + std::to_string(tmp) + " isn't a valid temperature."); } global_temps.add_temp(int(tmp) + correction_[0]); } } #endif /* USE_ATASMART */ #ifdef USE_NVML /*---------------------------------------------------------------------------- | NvmlSensorDriver: Gets temperatures directly from GPUs supported by the | | nVidia Management Library that is included with the proprietary driver. | ----------------------------------------------------------------------------*/ NvmlSensorDriver::NvmlSensorDriver(string bus_id, bool optional, vector correction) : SensorDriver(optional), dl_nvmlInit_v2(nullptr), dl_nvmlDeviceGetHandleByPciBusId_v2(nullptr), dl_nvmlDeviceGetName(nullptr), dl_nvmlDeviceGetTemperature(nullptr), dl_nvmlShutdown(nullptr) { if (!(nvml_so_handle_ = dlopen("libnvidia-ml.so", RTLD_LAZY))) { string msg = strerror(errno); throw SystemError("Failed to load NVML driver: " + msg); } /* Apparently GCC doesn't want to cast to function pointers, so we have to do * this kind of weird stuff. * See http://stackoverflow.com/questions/1096341/function-pointers-casting-in-c */ *reinterpret_cast(&dl_nvmlInit_v2) = dlsym(nvml_so_handle_, "nvmlInit_v2"); *reinterpret_cast(&dl_nvmlDeviceGetHandleByPciBusId_v2) = dlsym( nvml_so_handle_, "nvmlDeviceGetHandleByPciBusId_v2"); *reinterpret_cast(&dl_nvmlDeviceGetName) = dlsym(nvml_so_handle_, "nvmlDeviceGetName"); *reinterpret_cast(&dl_nvmlDeviceGetTemperature) = dlsym(nvml_so_handle_, "nvmlDeviceGetTemperature"); *reinterpret_cast(&dl_nvmlShutdown) = dlsym(nvml_so_handle_, "nvmlShutdown"); if (!(dl_nvmlDeviceGetHandleByPciBusId_v2 && dl_nvmlDeviceGetName && dl_nvmlDeviceGetTemperature && dl_nvmlInit_v2 && dl_nvmlShutdown)) throw SystemError("Incompatible NVML driver."); set_correction(correction); nvmlReturn_t ret; string name, brand; name.resize(256); brand.resize(256); if ((ret = dl_nvmlInit_v2())) throw SystemError("Failed to initialize NVML driver. Error code (cf. nvml.h): " + std::to_string(ret)); if ((ret = dl_nvmlDeviceGetHandleByPciBusId_v2(bus_id.c_str(), &device_))) throw SystemError("Failed to open PCI device " + bus_id + ". Error code (cf. nvml.h): " + std::to_string(ret)); dl_nvmlDeviceGetName(device_, &*name.begin(), 255); log(TF_DBG) << "Initialized NVML sensor on " << name << " at PCI " << bus_id << "." << flush; set_num_temps(1); } NvmlSensorDriver::~NvmlSensorDriver() noexcept(false) { nvmlReturn_t ret; if ((ret = dl_nvmlShutdown())) log(TF_ERR) << "Failed to shutdown NVML driver. Error code (cf. nvml.h): " << std::to_string(ret); dlclose(nvml_so_handle_); } void NvmlSensorDriver::read_temps_(TemperatureState &global_temps) const { nvmlReturn_t ret; unsigned int tmp; if ((ret = dl_nvmlDeviceGetTemperature(device_, NVML_TEMPERATURE_GPU, &tmp))) throw SystemError(MSG_T_GET(path_) + "Error code (cf. nvml.h): " + std::to_string(ret)); global_temps.add_temp(int(tmp)); } #endif /* USE_NVML */ } thinkfan-1.3.1/src/sensors.h000066400000000000000000000102121417751172400157570ustar00rootroot00000000000000#pragma once /******************************************************************** * config.h: Config data structures and consistency checking. * (C) 2015, Victor Mataré * * this file is part of thinkfan. See thinkfan.c for further information. * * thinkfan is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * thinkfan 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. * * You should have received a copy of the GNU General Public License * along with thinkfan. If not, see . * * ******************************************************************/ #include "thinkfan.h" #include "error.h" #ifdef USE_ATASMART #include #endif /* USE_ATASMART */ #ifdef USE_NVML #include #endif /* USE_NVML */ namespace thinkfan { class ExpectedError; class SensorDriver { protected: SensorDriver(string path, bool optional, vector correction = {}); SensorDriver(bool optional); public: virtual ~SensorDriver() noexcept(false); unsigned int num_temps() const { return num_temps_; } void set_correction(const vector &correction); void set_num_temps(unsigned int n); bool operator == (const SensorDriver &other) const; void set_optional(bool); bool optional() const; const string &path() const; inline void read_temps(TemperatureState &global_temps) const { try { read_temps_(global_temps); } catch (SystemError &e) { sensor_lost(e, global_temps); } catch (IOerror &e) { sensor_lost(e, global_temps); } catch (std::ios_base::failure &e) { sensor_lost(IOerror(e.what(), THINKFAN_IO_ERROR_CODE(e)), global_temps); } } protected: virtual void read_temps_(TemperatureState &global_temps) const = 0; string path_; vector correction_; private: unsigned int num_temps_; bool optional_; void check_correction_length(); inline void sensor_lost(const ExpectedError &e, TemperatureState &global_temps) const { if (this->optional() || tolerate_errors) log(TF_INF) << SensorLost(e).what(); else error(e); global_temps.add_temp(-128); } }; class TpSensorDriver : public SensorDriver { public: TpSensorDriver(string path, bool optional, vector correction = {}); TpSensorDriver(string path, bool optional, const vector &temp_indices, vector correction = {}); protected: virtual void read_temps_(TemperatureState &global_temps) const override; private: std::char_traits::off_type skip_bytes_; static const string skip_prefix_; vector in_use_; }; class HwmonSensorDriver : public SensorDriver { public: HwmonSensorDriver(string path, bool optional, vector correction = {}); protected: virtual void read_temps_(TemperatureState &global_temps) const override; }; #ifdef USE_ATASMART class AtasmartSensorDriver : public SensorDriver { public: AtasmartSensorDriver(string device_path, bool optional, vector correction = {}); virtual ~AtasmartSensorDriver(); protected: virtual void read_temps_(TemperatureState &global_temps) const override; private: SkDisk *disk_; }; #endif /* USE_ATASMART */ #ifdef USE_NVML class NvmlSensorDriver : public SensorDriver { public: NvmlSensorDriver(string bus_id, bool optional, vector correction = {}); virtual ~NvmlSensorDriver() noexcept(false) override; protected: virtual void read_temps_(TemperatureState &global_temps) const override; private: nvmlDevice_t device_; void *nvml_so_handle_; // Pointers to dynamically loaded functions from libnvidia-ml.so nvmlReturn_t (*dl_nvmlInit_v2)(); nvmlReturn_t (*dl_nvmlDeviceGetHandleByPciBusId_v2)(const char *, nvmlDevice_t *); nvmlReturn_t (*dl_nvmlDeviceGetName)(nvmlDevice_t, char *, unsigned int); nvmlReturn_t (*dl_nvmlDeviceGetTemperature)(nvmlDevice_t, nvmlTemperatureSensors_t, unsigned int *); nvmlReturn_t (*dl_nvmlShutdown)(); }; #endif /* USE_NVML */ } thinkfan-1.3.1/src/thinkfan.1.cmake000066400000000000000000000131371417751172400170660ustar00rootroot00000000000000.TH THINKFAN "5" "December 2021" "thinkfan @THINKFAN_VERSION@" "thinkfan" .SH NAME thinkfan \- A simple fan control program .SH SYNOPSIS .SY thinkfan .OP \-hnqDd .OP \-b BIAS .OP \-c CONFIG .OP \-s SECONDS .OP \-p \fR[\fIDELAY\fR]\fI .YS .SH DESCRIPTION Thinkfan sets the fan speed according to temperature limits set in the config file. It can read temperatures from a number of sources: .IP "/proc/acpi/ibm/thermal" Which is provided by the thinkpad_acpi kernel module on older Thinkpads, .IP "temp*_input files in sysfs" Which may be provided by any hwmon drivers, including thinkpad_acpi on modern Thinkpads, .IP "Hard disks with S.M.A.R.T. support" With the help of libatasmart, if thinkfan was compiled with .B \-DUSE_ATASMART=ON .IP "From the proprietary nVidia driver" When the proprietary nVidia driver is used, no hwmon for the card will be available. In this situation, thinkfan can use the proprietary NVML API to get temperatures. .P The fan can be /proc/acpi/ibm/fan or some PWM file in /sys/class/hwmon. See .BR thinkfan.conf (5) for a detailed explanation of the config syntax. .HP \fBWARNING\fR: This program does only very basic sanity checking on the configuration. That means that you can set your temperature limits as insane as you like. .P There are two general modes of operation: .SS COMPLEX MODE In complex mode, temperature limits are defined for each sensor thinkfan knows about. Setting suitable limits for each sensor in your system will probably require a bit of experimentation and good knowledge about your hardware, but it's the safest way of keeping each component within its specified temperature range. See http://www.thinkwiki.org/wiki/Thermal_Sensors for details on which sensor measures what temperature in a Thinkpad. On other systems you'll have to find out on your own. See the example configs to learn about the syntax. .SS SIMPLE MODE In simple mode, Thinkfan uses only the highest temperature found in the system. That may be dangerous, e.g. for hard disks. That's why you should provide a correction value (i.e. add 10\-15 \[char176]C) for the sensor that has the temperature of your hard disk (or battery...). See the example config files for details about that. .SH CONFIGURATION Some example configurations are provided with the source package. For a detailed see the config man page .BR thinkfan.conf (5). .SH OPTIONS .TP .B \-h Show a short help message .TP .BI \-s " SECONDS" Maximum seconds between temperature updates (default: 5) .TP .BI \-b " BIAS" Floating point number (\-10 to 30) to control rising temperature exaggeration. If the temperature increases by more than 2 \[char176]C during one cycle, this number is used to calculate a bias, which is added to the current highest temperature seen in the system: current_tmax = current_tmax + delta_t * \fIBIAS\fR / 10 This means that negative numbers can be used to even out short and sudden temperature spikes like those seen on some on\-DIE sensors. Use DANGEROUS mode to remove the \-10 to +30 limit. Note that you can't have a space between \-b and a negative argument, because otherwise getopt will interpret things like \-10 as an option and fail (i.e. write .B \-b\-10 instead of .BR "\-b \-10" ). Default is 15.0 .TP .BI \-c " FILE" Load a different configuration file. By default, thinkfan first tries to load /etc/thinkfan.yaml, and /etc/thinkfan.conf after that. The former must be in YAML format, while the latter can be either YAML or the old legacy syntax. If this option is specified, thinkfan attempts to load the config only from .IR FILE . If its name ends in \*(lq.yaml\*(rq, it must be in YAML format. Otherwise, it can be either YAML or legacy syntax. See .BR thinkfan.conf (5) and .BR thinkfan.conf.legacy (5) for details. .TP .B \-n Do not become a daemon and log to terminal instead of syslog .TP .B \-q Be quiet, i.e. reduce logging level from the default. Can be specified multiple times until only errors are displayed/logged. .TP .B \-v Be more verbose. Can be specified multiple times until every message is displayed/logged. .TP .BR "\-p " [\fISECONDS\fR] Use the pulsing\-fan workaround (for older Thinkpads). Takes an optional floating\-point argument (0\-10s) as depulsing duration. Default 0.5s. .TP .B \-d Do not read temperature from sleeping disks. Instead, 0 \[char176]C is used as that disk's temperature. This is needed if reading the temperature causes your disk to wake up unnecessarily. NOTE: This option is only available if thinkfan was built with \-D USE_ATASMART. .TP .B \-D DANGEROUS mode: Disable all sanity checks. May damage your hardware!! .SH SIGNALS SIGINT and SIGTERM simply interrupt operation and should cause thinkfan to terminate cleanly. .P SIGHUP makes thinkfan reload its config. If there's any problem with the new config, we keep the old one. .P SIGUSR1 causes thinkfan to dump all currently known temperatures either to syslog, or to the console (if running with the \-n option). .SH RETURN VALUE .TP .B 0 Normal exit .TP .B 1 Runtime error .TP .B 2 Unexpected runtime error .TP .B 3 Invalid commandline option .SH SEE ALSO .nf The thinkfan config manpage: .BR thinkfan.conf (5) Example configs shipped with the source distribution, also available at: .hy 0 https://github.com/vmatare/thinkfan/tree/master/examples The Linux hwmon user interface documentation: https://www.kernel.org/doc/html/latest/hwmon/sysfs\-interface.html The thinkpad_acpi interface documentation: https://www.kernel.org/doc/html/latest/admin\-guide/laptops/thinkpad\-acpi.html .SH BUGS If thinkfan tells you to, or if you feel like it, report issues at the Github issue tracker: .hy 0 https://github.com/vmatare/thinkfan/issues thinkfan-1.3.1/src/thinkfan.conf.5.cmake000066400000000000000000000265761417751172400200310ustar00rootroot00000000000000.TH THINKFAN.CONF 5 "December 2021" "thinkfan @THINKFAN_VERSION@" .SH NAME thinkfan.conf \- YAML-formatted config for .BR thinkfan (1) .SH DESCRIPTION YAML is a very powerful, yet concise notation for structured data. Its full specification is available at https://yaml.org/spec/1.2/spec.html. Thinkfan uses only a small subset of the full YAML syntax, so it may be helpful, but not strictly necessary for users to take a look at the spec. The most important thing to note is that indentation is syntactically relevant. In particular, tabs should not be mixed with spaces. We recommend using two spaces for indentation, like it is shown below. The thinkfan config has three main sections: .TP 11m .B sensors: Where temperatures should be read from. All .BR hwmon -style drivers are supported, as well as .BR /proc/acpi/ibm/thermal , and, depending on the compile-time options, .B libatasmart (to read temperatures directly from hard disks) and .B NVML (via the proprietary nvidia driver). .TP .B fans: Which fans should be used (currently only one allowed). Support for multiple fans is currently in development and planned for a future release. Both .BR hwmon -style PWM controls and .B /proc/acpi/ibm/fan can be used. .TP .B levels: Maps temperatures to fan speeds. A \*(lqsimple mapping\*(rq just specifies one temperature as the lower and upper bound (respectively) for a given fan speed. In a \*(lqdetailed mapping\*(rq, the upper and lower bounds are specified for each driver/sensor configured under .BR sensors: . This mode should be used when thinkfan is monitoring multiple devices that can tolerate different amounts of heat. .PP Under each of these sections, there must be a list of key-value maps, each of which configures a sensor driver, fan driver or fan speed mapping. .SH SENSOR & FAN DRIVERS For thinkfan to work, it first needs to know which temperature sensor drivers and which fan drivers it should use. The mapping between temperature readings and fan speeds is specified in a separate config section (see the .B FAN SPEEDS section below). .SS Sensor Syntax The entries under the .B sensors: section can specify .BR hwmon, .BR thinkpad_acpi, .BR NVML or .BR atasmart drivers, where the latter two must be enabled at compile-time. There can be any number (greater than zero) and combination of .BR hwmon , .BR tpacpi , .BR nvml and .BR atasmart entries. However there may be at most one instance of the .BR tpacpi entry. .nf .B "sensors:" .BI " \- hwmon: " hwmon-path .BI " name: " hwmon-name .BI " indices: " index-list .BI " correction: " correction-list .BI " optional: " bool-allow-errors .B " \- tpacpi: /proc/acpi/ibm/thermal" .BI " indices: " index-list .BI " correction: " correction-list .BI " optional: " bool-allow-errors .BI " \- nvml: " nvml-bus-id .BI " correction: " correction-list .BI " optional: " bool-allow-errors .BI " \- atasmart: " disk-device-file .BI " correction: " correction-list .BI " optional: " bool-allow-errors .BR " \- " ... .fi .SS Fan Syntax Currently, thinkfan supports only one fan, so there can be only one entry in the list. Support for multiple fans is currently in development and planned for a future release. The fan is either an .B hwmon fan: .nf .B "fans:" .BI " \- hwmon: " hwmon-path .BI " name: " hwmon-name .BI " indices: " index-list .fi or a .B tpacpi fan: .nf .B "fans:" .B " \- tpacpi: /proc/acpi/ibm/fan" .fi .SS Values .TP 12m .I hwmon-path There are three ways of specifying hwmon fans or sensors: .TP \h'8m'1) A full path of a \*(lqtemp*_input\*(rq or \*(lqpwm*\*(rq file, like \*(lq/sys/class/hwmon/hwmon0/pwm1\*(rq or \*(lq/sys/class/hwmon/hwmon0/temp1_input\*(rq. In this case, the \*(lq\c .BI indices: " index-list"\c \*(rq and \*(lq\c .BI name: " hwmon-name"\c \*(rq entries are unnecessary since the path uniquely identifies a specific fan or sensor. Note that this method may lead to problems when the load order of the drivers changes across bootups, because in the \*(lqhwmon\fIX\fR\*(rq folder name, the .I X actually corresponds to the load order. Use method 2) or 3) to avoid this problem. .TP \h'8m'2) A directory that contains a specific hwmon driver, for example \*(lq/sys/devices/platform/nct6775.2592\*(rq. Note that this path does not contain the load-order dependent \*(lqhwmon\fIX\fR\*(rq folder. As long as it contains only a single hwmon driver/interface it is sufficient to specify the \*(lq\c .BI indices: " index-list"\c \*(rq entry to tell thinkfan which specific sensors to use from that interface. The \*(lq\c .BI name: " hwmon-name"\c \*(rq entry is unnecessary. .TP \h'8m'3) A directory that contains multiple or all of the hwmon drivers, for example \*(lq/sys/class/hwmon\*(rq. Here, both the \*(lq\c .BI name: " hwmon-name"\c \*(rq and \*(lq\c .BI indices: " index-list"\c \*(rq entries are required to tell thinkfan which interface to select below that path, and which sensors or which fan to use from that interface. .TP .I hwmon-name The name of a hwmon interface, typically found in a file called \*(lqname\*(rq. This has to be specified if .I hwmon-path is a base path that contains multiple hwmons. This method of specifying sensors is particularly useful if the full path to a particular hwmon keeps changing between bootups, e.g. due to changing load order of the driver modules. .TP .I index-list A YAML list .BI "[ " X1 ", " X2 ", " "\fR...\fB ]" that specifies which sensors, resp. which fan to use from a given interface. Both .B /proc/acpi/ibm/thermal and also many hwmon interfaces contain multiple sensors, and not all of them may be relevant for fan control. .TP \h'9m'\(bu For .B hwmon entries, this is required if .I hwmon-path does not refer directly to a single \*(lqtemp\fIXi\fR_input\*(rq file, but to a folder that contains one or more of them. In this case, .I index-list specifies the .I Xi for the \*(lqtemp\fIXi\fR_input\*(rq files that should be used. A hwmon interface may also contain multiple PWM controls for fans, so in that case, .I index-list must contain exactly one entry. .TP \h'9m'\(bu For .B tpacpi sensors, this entry is optional. If it is omitted, all temperatures found in .B /proc/acpi/ibm/thermal will be used. .TP .I nvml-bus-id NOTE: only available if thinkfan was compiled with USE_NVML enabled. The PCI bus ID of an nVidia graphics card that is run with the proprietary nVidia driver. Can be obtained with e.g. \*(lqlspci | grep \-i vga\*(rq. Usually, nVidia cards will use the open source .B nouveau driver, which should support hwmon sensors instead. .TP .I disk-device-file NOTE: only available if thinkfan was compiled with USE_ATASMART enabled. Full path to a device file for a hard disk that supports S.M.A.R.T. See also the .B \-d option in .BR thinkfan (1) that prevents thinkfan from waking up sleeping (mechanical) disks to read their temperature. .TP .IR correction-list " (always optional)" A YAML list that specifies temperature offsets for each sensor in use by the given driver. Use this if you want to use the \*(lqsimple\*(rq level syntax, but need to compensate for devices with a lower heat tolerance. Note however that the detailed level syntax is usually the better (i.e. more fine-grained) choice. .TP .IR bool-allow-errors " (always optional, \fBfalse\fR by default)" A truth value .RB ( yes / no / true / false ) that specifies whether thinkfan should accept errors when reading from this sensor. Normally, thinkfan will exit with an error message if reading the temperature from any configured sensor fails. Marking a sensor as optional may be useful for removable hardware or devices that may get switched off entirely to save power. .SH FAN SPEEDS The .B levels: section specifies a list of fan speeds with associated lower and upper temperature bounds. If temperature(s) drop below the lower bound, thinkfan switches to the previous level, and if the upper bound is reached, thinkfan switches to the next level. .SS Simple Syntax In the simplified form, only one temperature is specified as an upper/lower limit for a given fan speed. In that case, the .I lower-bound and .I upper-bound are compared only to the highest temperature found among all configured sensors. All other temperatures are ignored. This mode is suitable for small systems (like laptops) where there is only one device (e.g. the CPU) whose temperature needs to be controlled, or where the required fan behaviour is similar enough for all heat-generating devices. .nf .B "levels:" .BI " \- [ " fan-speed ", " lower-bound ", " upper-bound " ]" .BR " \- " ... .fi .SS Detailed Syntax This mode is suitable for more complex systems, with devices that have different temperature ratings. For example, many modern CPUs and GPUs can deal with temperatures above 80\[char176]C on a daily basis, whereas a hard disk will die quickly if it reaches such temperatures. In detailed mode, upper and lower temperature limits are specified for each sensor individually: .nf .B "levels:" .BI " \- speed: " fan-speed .BI " lower_limit: [ " l1 ", " l2 ", " "\fR..." " ]" .BI " upper_limit: [ " u1 ", " u2 ", " "\fR..." " ]" .BR " \- " ... .fi .SS Values .TP 12m .I fan-speed The possible speed values are different depending on which fan driver is used. For a .B hwmon fan, .I fan-speed is a numeric value ranging from .B 0 to .BR 255 , corresponding to the PWM values accepted by the various kernel drivers. For a .B tpacpi fan on Lenovo/IBM ThinkPads and some other Lenovo laptops (see \fBSENSORS & FAN DRIVERS\fR above), numeric values and strings can be used. The numeric values range from 0 to 7. The string values take the form \fB"level \fIlvl-id\fB"\fR, where .I lvl-id may be a value from .BR 0 " to " 7 , .BR auto , .B full-speed or .BR disengaged . The numeric values .BR 0 " to " 7 correspond to the regular fan speeds used by the firmware, although many firmwares don't even use level \fB7\fR. The value \fB"level auto"\fR gives control back to the firmware, which may be useful if the fan behavior only needs to be changed for certain specific temperature ranges (usually at the high and low end of the range). The values \fB"level full-speed"\fR and \fB"level disengaged"\fR take the fan speed control away from the firmware, causing the fan to slowly ramp up to an absolute maximum that can be achieved within electrical limits. Note that this will run the fan out of specification and cause increased wear, though it may be helpful to combat thermal throttling. .TP .IB l1 ", " l2 ", " \fR... .TP .IB u1 ", " u2 ", " \fR... The lower and upper limits refer to the sensors in the same order in which they were found when processing the .B sensors: section (see .B SENSOR & FAN DRIVERS above). For the first level entry, the .B lower_limit may be omitted, and for the last one, the .B upper_limit may be omitted. For all levels in between, the lower limits must overlap with the upper limits of the previous level, to make sure the entire temperature range is covered and that there is some hysteresis between speed levels. .SH SEE ALSO .nf The thinkfan manpage: .BR thinkfan (1) Example configs shipped with the source distribution, also available at: .hy 0 https://github.com/vmatare/thinkfan/tree/master/examples The Linux hwmon user interface documentation: https://www.kernel.org/doc/html/latest/hwmon/sysfs\-interface.html The thinkpad_acpi interface documentation: https://www.kernel.org/doc/html/latest/admin\-guide/laptops/thinkpad\-acpi.html .SH BUGS .hy 0 .nf Report bugs on the github issue tracker: https://github.com/vmatare/thinkfan/issues thinkfan-1.3.1/src/thinkfan.conf.legacy.5.cmake000066400000000000000000000212541417751172400212600ustar00rootroot00000000000000.TH THINKFAN.CONF.LEGACY 5 2020-04-09 "thinkfan @THINKFAN_VERSION@" .SH NAME thinkfan.conf.legacy \- the old, backwards-compatible config syntax for thinkfan .BR thinkfan (1) .SH DESCRIPTION The thinkfan config file specifies one or more temperature input(s), exactly one fan to control and the fan levels. A fan level associates a certain fan speed to a lower and an upper temperature bound. If the temperature reaches the upper bound, we switch to the next fan level, and if it drops below the lower bound, we switch to the previous fan level. Temperature bounds can either be a single temperature (\fIsimple mode\fR) or consist of multiple temperatures (\fIcomplex mode\fR). In simple mode, only the highest of all known temperature is compared to the upper & lower bound. If you have devices with very different temperature ratings (e.g. CPU vs. mechanical hard drives), you should specify correction values to equalize their temperature ranges, or better: use complex mode. In complex mode, the upper and lower bounds of each fan level are specified for each sensor individually. Thinkfan then switches to the next fan level if one of the upper bounds is reached, and to the previous fan level if all temperatures have dropped below their respective lower bounds. .SH THERMAL SENSORS Multiple sensor keywords can be combined in one config file, but note that the ordering is significant with respect to the upper and lower fan level bounds if you use \fIcomplex mode\fR. I.e. if .B /proc/acpi/ibm/thermal contains 16 temperatures and you specify an .B hwmon sensor after the .B tp_thermal statement, the .B hwmon sensor will be the 17th temperature. . After each sensor path, an optional .I correction-value can be specified. This value (can be negative) is always added to the temperature reading from that sensor. Correction values should be specified if you use .B Simple Mode with components that have a different temperature rating, like hard disks and CPUs. Note though that .B Complex Mode is generally the better solution since it gives you full control over fan levels and temperature ranges for each sensor, instead of just adding a fixed value to equalize temperature ranges. .TP .BI "tp_thermal /proc/acpi/ibm/thermal" " \fR[\fB (\fIcorrection-value \fR...\fB) \fR]\fP" Use the thermal sensors provided by the .B thinkpad_acpi kernel module on older thinkpads. These normally reside in .B /proc/acpi/ibm/thermal, so this keyword will hardly be used with other paths. This file usually contains 8-16 temperatures, some of which may be reserved for removable hardware or completely unused. Unused temperature slots always contain the value -128. Since this file contains all temperatures the .B thinkpad_acpi module knows about, there cannot be more than one .B tp_thermal statement in a config file. .TP .BI hwmon " sysfs-path \fR[ \fB(\fIcorrection-value\fB) \fR]\fP" Use a standard hwmon temperature input that may be provided by all kinds of kernel drivers. .I sysfs-path is usually a file named \[oq]temp*_input\[cq], somewhere under /sys, so you can search for them e.g. with \[oq]find /sys -type f -name "temp*_input"\[cq]. Each of these files contains one temperature, so you need to add a .B hwmon statement for each device whose temperature you wish to control. .TP .BI atasmart " device-path \fR[ \fB(\fIcorrection-value\fB) \fR]\fP" NOTE: only available if thinkfan was compiled with USE_ATASMART enabled. . .IP Read the temperature directly from a hard disk using S.M.A.R.T. See also the .B -d option in .BR thinkfan (1) that prevents thinkfan from waking up sleeping (mechanical) disks to read their temperature. .TP .BI nv_thermal " pci-bus-id \fR[ \fB(\fIcorrection-value\fB) \fR]\fP" NOTE: only available if thinkfan was compiled with USE_NVML enabled. . .IP Read the temperature of an nVidia graphics card from the proprietary nVidia driver. This does not work with the open-source Nouveau driver, it depends specifially on libnvidia-ml.so that is usually installed with the binary nVidia driver. The correct .I pci-bus-id can be retrieved using e.g. lspci with: \[oq]lspci | grep -i vga\[cq]. Most open-source graphics drivers (radeon, nouveau, possibly others too) can instead be used with the .B hwmon keyword described above. .SH FANS Currently, thinkfan can control only one fan at a time. In theory, you can run multiple instances of the program simultaneously (with multiple config files) to control multiple fans, but that requires enabling DANGEROUS mode and will likely break most init scripts. It is an error to have more than one fan statement per config file. .TP .B tp_fan /proc/acpi/ibm/fan Use the fan control provided by the .B thinkpad_acpi kernel module, which needs to be loaded with the option .BR fan_control=1 . The path is defined by the .B thinkpad_acpi kernel module and will hardly change. Besides the fan levels ranging from 0 to 7, it also supports the .B disengaged and .B auto modes. . .IP The .B auto mode should delegate fan control to the firmware, so it can be regarded as a \[oq]default\[cq] mode that does not change the fan behavior. This is useful for example if you only want to change the fan behavior at high and/or low temperatures. . .IP The .B disengaged or .B full-speed mode effectively disables the fan RPM limiter. Fan speed will slowly ramp up until the fan uses the maximum electrical power available from the embedded controller. Use this only to prevent potentially destructive overheating, since it runs the fan outside of specifications and wears its bearings down quickly. .TP .BI pwm_fan " sysfs-path" Control a sysfs PWM fan. Many hwmon drivers that provide a \[oq]temp*_input\[cq] file also allow fan control, although there may also be drivers that are specific to either temperature reading or fan control. You can search for a PWM control file e.g. with \[oq]find /sys -type f -name "pwm?"\[cq]. Note that with PWM, fan levels usually range from 0 to 255, although besides a file like \fBpwm1\fR there may also be \fBpwm1_min\fR and \fBpwm1_max\fR that specify different (soft or recommended?) limits for a particular fan. .SH FAN LEVELS Defining the fan levels is the meat of the config file. Here you make use of your previously defined temperature inputs to set the lower and upper bounds for the fan speeds. You cannot mix simple fan levels with complex fan levels. The general syntax of a simple fan level is: .RS .PP \fB( \fIfan-level \fR[\fB,\fR] \fIlower-bound \fR[\fB,\fR] \fIupper-bound\fB ) .RE .PP The .I fan-level is either a numeric value (0-7 or 0-255, depending on whether a .B tp_fan or a .B pwm_fan is used) or a string enclosed in double quotes. When a .B tp_fan is used, specifying .B 0 has the same effect as specifying \fB"level 0\fR". In addition to the numeric fan levels, .B tp_fan also supports \fB"level auto"\fR and \fB"level disengaged"\fR or \fB"level full-speed"\fR. See above for an explanation of what these mean. The format of .I lower-bound and .I upper-bound depends on whether you want to use .B Simple Mode or .B Complex Mode. .SS Simple Mode In simple mode, the .I lower-bound and .I upper-bound of a fan level are each specified as a single temperature value. Both are compared only to the highest temperature found in all of the configured thermal sensors. Using this mode of operation makes sense e.g. if all temperature readings come from the on-DIE thermal sensors of a multicore processor. The fan speed will affect all of these temperatures in the same way because they share a single thermal connection to the heatsink, so it makes sense to ignore all but the highest of these temperatures. As a rule of thumb, if your thermal sensors cover multiple devices you should use Complex Mode, or at least specify correction values to account for different temperature ratings. .SS Complex Mode In complex mode, both the .I lower-bound and .I upper-bound are lists of temperatures, the length of which must match the number of temperature readings thinkfan knows about. Each bound must be enclosed in braces, with individual values separated by commas or spaces, so the specific syntax of a complex mode fan level is: .RS .PP .nf .B "{ \fIfan-level" .B " ( \fIlower-1 \fR[\fIlower-2\fR ...] \fB)" .B " ( \fIupper-1 \fR[\fIupper-2\fR ...] \fB)" .B "}" .fi .RE .PP The optional commas have been omitted here for readability, and the curly braces are interchangeable with round braces. Note that it is not possible to mix simple fan levels with complex fan levels. .P Complex mode is generally the preferred mode of operation since it allows you to specify precisely what the fan should to to keep each component within its specified temperature range. .SH SEE ALSO .BR thinkfan (1) .P Example configs shipped with the source distribution, also available at .IR https://github.com/vmatare/thinkfan/tree/master/examples . thinkfan-1.3.1/src/thinkfan.cpp000066400000000000000000000305121417751172400164250ustar00rootroot00000000000000/******************************************************************** * thinkfan.cpp: Main program. * (C) 2015, Victor Mataré * * this file is part of thinkfan. * * thinkfan is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * thinkfan 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. * * You should have received a copy of the GNU General Public License * along with thinkfan. If not, see . * * ******************************************************************/ #include "error.h" #include #include #include #include #include #include #include #include #include #include #include #include #include "thinkfan.h" #include "config.h" #include "message.h" #include "error.h" namespace thinkfan { bool chk_sanity(true); bool quiet(false); bool daemonize(true); seconds sleeptime(5); seconds tmp_sleeptime = sleeptime; float bias_level(1.5); float depulse = 0; TemperatureState temp_state(0); std::atomic tolerate_errors(0); std::condition_variable sleep_cond; std::mutex sleep_mutex; #ifdef USE_YAML vector config_files { DEFAULT_YAML_CONFIG, DEFAULT_CONFIG }; #else vector config_files { DEFAULT_CONFIG }; #endif std::atomic interrupted(0); #ifdef USE_ATASMART /** Do Not Disturb disk, i.e. don't get temperature from a sleeping disk */ bool dnd_disk = false; #endif /* USE_ATASMART */ void sig_handler(int signum) { switch(signum) { case SIGHUP: case SIGINT: case SIGTERM: interrupted = signum; sleep_cond.notify_all(); break; case SIGUSR1: log(TF_NFY) << temp_state << flush; break; #ifndef DISABLE_BUGGER case SIGSEGV: // Let's hope memory isn't too fucked up to get through with this ;) throw Bug("Segmentation fault."); #endif case SIGUSR2: interrupted = signum; sleep_cond.notify_all(); log(TF_NFY) << "Received SIGUSR2: Re-initializing fan control." << flush; break; case SIGWINCH: tolerate_errors = 4; log(TF_NFY) << "Going to sleep: Will allow sensor read errors for the next " << std::to_string(tolerate_errors) << " loops." << flush; } } static inline void read_temps(const vector> &sensors) { temp_state.restart(); for (const unique_ptr &sensor : sensors) sensor->read_temps(temp_state); } void run(const Config &config) { tmp_sleeptime = sleeptime; read_temps(config.sensors()); temp_state.init(); // Set initial fan level for (auto &fan_config : config.fan_configs()) fan_config->init_fanspeed(temp_state); log(TF_NFY) << temp_state << " -> " << config.fan_configs() << flush; bool did_something = false; while (likely(!interrupted)) { auto until = std::chrono::steady_clock::now() + tmp_sleeptime; std::unique_lock sleep_locked(sleep_mutex); sleep_cond.wait_until(sleep_locked, until, [] () { return interrupted != 0; } ); if (unlikely(interrupted)) break; read_temps(config.sensors()); if (unlikely(tolerate_errors) > 0) tolerate_errors--; if (unlikely(!temp_state.complete())) throw SystemError(MSG_SENSOR_LOST); for (auto &fan_config : config.fan_configs()) did_something |= fan_config->set_fanspeed(temp_state); if (unlikely(did_something)) log(TF_NFY) << temp_state << " -> " << config.fan_configs() << flush; did_something = false; } } int set_options(int argc, char **argv) { const char *optstring = "c:s:b:p::hqDznv" #ifdef USE_ATASMART "d"; #else ; #endif opterr = 0; int opt; while ((opt = getopt(argc, argv, optstring)) != -1) { switch(opt) { case 'h': log(TF_NFY) << MSG_TITLE << flush << MSG_USAGE << flush; return 1; #ifdef USE_ATASMART case 'd': dnd_disk = true; break; #endif case 'c': config_files = vector({optarg}); break; case 'q': --Logger::instance().log_lvl(); break; case 'v': ++Logger::instance().log_lvl(); break; case 'D': chk_sanity = false; break; case 'z': log(TF_WRN) << "Option -z is not needed anymore and therefore deprecated." << flush; break; case 'n': daemonize = false; break; case 's': if (optarg) { try { size_t invalid; int s; string arg(optarg); s = int(std::stoul(arg, &invalid)); if (invalid < arg.length()) throw InvocationError(MSG_OPT_S_INVAL(optarg)); if (s > 15) throw InvocationError(MSG_OPT_S_15(s)); else if (s < 0) throw InvocationError("Negative sleep time? Seriously?"); else if (s < 1) throw InvocationError(MSG_OPT_S_1(s)); sleeptime = seconds(static_cast(s)); } catch (std::invalid_argument &) { throw InvocationError(MSG_OPT_S_INVAL(optarg)); } catch (std::out_of_range &) { throw InvocationError(MSG_OPT_S_INVAL(optarg)); } } else throw InvocationError(MSG_OPT_S); break; case 'b': if (optarg) { try { size_t invalid; float b; string arg(optarg); b = std::stof(arg, &invalid); if (invalid < arg.length()) error(MSG_OPT_B_INVAL(optarg)); if (b < -10 || b > 30) error(MSG_OPT_B); bias_level = b / 10; } catch (std::invalid_argument &) { throw InvocationError(MSG_OPT_B_INVAL(optarg)); } catch (std::out_of_range &) { throw InvocationError(MSG_OPT_B_INVAL(optarg)); } } else throw InvocationError(MSG_OPT_B_NOARG); break; case 'p': if (optarg) { size_t invalid; string arg(optarg); depulse = std::stof(arg, &invalid); if (invalid < arg.length() || depulse > 10 || depulse < 0) error(MSG_OPT_P(optarg)); } else depulse = 0.5f; break; default: throw InvocationError(string("Unknown option: -") + static_cast(optopt)); } } if (depulse > 0) log(TF_NFY) << MSG_DEPULSE(depulse, sleeptime.count()) << flush; return 0; } #if defined(PID_FILE) PidFileHolder *PidFileHolder::instance_ = nullptr; PidFileHolder::PidFileHolder(::pid_t pid) : pid_file_(PID_FILE, std::ios_base::in) { if (!pid_file_.fail()) error(MSG_RUNNING); if (instance_) throw Bug("Attempt to initialize PID file twice"); pid_file_.close(); pid_file_.open(PID_FILE, std::ios_base::out | std::ios_base::trunc); if (!(pid_file_ << pid << std::flush)) error("Writing to " PID_FILE ": ", errno); instance_ = this; } PidFileHolder::~PidFileHolder() { remove_file(); } bool PidFileHolder::file_exists() { return !ifstream(PID_FILE).fail(); } void PidFileHolder::remove_file() { if (pid_file_.is_open()) { pid_file_.close(); if (::unlink(PID_FILE) == -1) log(TF_ERR) << "Deleting " PID_FILE ": " << errno << "." << flush; } } void PidFileHolder::cleanup() { if (instance_) instance_->remove_file(); } #else void PidFileHolder::cleanup() {} #endif // defined(PID_FILE) TemperatureState::TemperatureState(unsigned int num_temps) : temps_(num_temps, 0), biases_(num_temps, 0), biased_temps_(num_temps, 0), temp_(temps_.begin()), bias_(biases_.begin()), biased_temp_(biased_temps_.begin()), tmax(biased_temps_.begin()) {} void TemperatureState::restart() { temp_ = temps_.begin(); bias_ = biases_.begin(); biased_temp_ = biased_temps_.begin(); tmax = biased_temps_.begin(); } void TemperatureState::add_temp(int t) { int diff = *temp_ >= 0 ? t - *temp_ : 0; *temp_ = t; if (unlikely(diff > 2)) { // Apply bias_ if temperature changed quickly float tmp_bias = float(diff) * bias_level; *bias_ = int(tmp_bias); if (tmp_sleeptime > seconds(2)) tmp_sleeptime = seconds(2); } else { if (unlikely(diff < 0)) { // Return to normal operation if temperature dropped tmp_sleeptime = sleeptime; *bias_ = 0; } else { // Slowly return to normal sleeptime if (unlikely(tmp_sleeptime < sleeptime)) tmp_sleeptime++; // slowly reduce the bias_ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wfloat-equal" // bias is set to 0 explicitly if (unlikely(*bias_ != 0)) { #pragma GCC diagnostic pop if (std::abs(*bias_) < 0.5f) *bias_ = 0; else *bias_ -= 1 + *bias_/5 ; } } } *biased_temp_ = *temp_ + int(*bias_); if (*biased_temp_ > *tmax) tmax = biased_temp_; ++temp_; ++bias_; ++biased_temp_; } bool TemperatureState::complete() const { return temp_ == temps_.end(); } const vector & TemperatureState::biased_temps() const { return biased_temps_; } const vector & TemperatureState::temps() const { return temps_; } const vector & TemperatureState::biases() const { return biases_; } void TemperatureState::init() { biases_.clear(); biases_.resize(temps_.size(), 0); biased_temps_ = temps_; } } // namespace thinkfan int main(int argc, char **argv) { using namespace thinkfan; struct sigaction handler; #if defined(PID_FILE) unique_ptr pid_file; #endif if (!isatty(fileno(stdout))) { Logger::instance().enable_syslog(); } #if not defined(DISABLE_BUGGER) std::set_terminate(handle_uncaught); #endif memset(&handler, 0, sizeof(handler)); handler.sa_handler = sig_handler; if (sigaction(SIGHUP, &handler, nullptr) || sigaction(SIGINT, &handler, nullptr) || sigaction(SIGTERM, &handler, nullptr) || sigaction(SIGUSR1, &handler, nullptr) || sigaction(SIGWINCH, &handler, nullptr) #if not defined(DISABLE_BUGGER) || sigaction(SIGSEGV, &handler, nullptr) #endif || sigaction(SIGUSR2, &handler, nullptr)) { string msg = strerror(errno); log(TF_ERR) << "sigaction: " << msg; return 1; } #if not defined(DISABLE_EXCEPTION_CATCHING) try { #endif // DISABLE_EXCEPTION_CATCHING switch (set_options(argc, argv)) { case 1: return 0; case 0: break; default: return 3; } #if defined(PID_FILE) if (PidFileHolder::file_exists()) error(MSG_RUNNING); #endif if (daemonize) { { // Test the config before forking LogLevel old_lvl = Logger::instance().log_lvl(); Logger::instance().log_lvl() = TF_ERR; unique_ptr test_cfg(Config::read_config(config_files)); temp_state = TemperatureState(test_cfg->num_temps()); temp_state.init(); test_cfg->init_fans(); read_temps(test_cfg->sensors()); Logger::instance().log_lvl() = old_lvl; // Own scope so the config gets destroyed before forking } pid_t child_pid = ::fork(); if (child_pid < 0) { string msg(strerror(errno)); error("Can't fork(): " + msg); } else if (child_pid > 0) { log(TF_NFY) << "Daemon PID: " << child_pid << flush; return 0; } else { Logger::instance().enable_syslog(); #if defined(PID_FILE) // Own PID file only in the child... pid_file.reset(new PidFileHolder(::getpid())); #endif } } #if defined(PID_FILE) else { // ... or when we're not forking at all pid_file.reset(new PidFileHolder(::getpid())); } #endif // Load the config for real after forking & enabling syslog unique_ptr config(Config::read_config(config_files)); temp_state = TemperatureState(config->num_temps()); do { config->init_fans(); run(*config); if (interrupted == SIGHUP) { log(TF_NFY) << MSG_RELOAD_CONF << flush; try { unique_ptr config_new(Config::read_config(config_files)); config.swap(config_new); } catch(ExpectedError &) { log(TF_ERR) << MSG_CONF_RELOAD_ERR << flush; } catch(std::exception &e) { log(TF_ERR) << "read_config: " << e.what() << flush; log(TF_ERR) << MSG_CONF_RELOAD_ERR << flush; } interrupted = 0; } else if (interrupted == SIGUSR2) { config->init_fans(); interrupted = 0; } } while (!interrupted); log(TF_NFY) << MSG_TERM << flush; #if not defined(DISABLE_EXCEPTION_CATCHING) } catch (InvocationError &e) { log(TF_ERR) << e.what() << flush; log(TF_NFY) << MSG_USAGE << flush; } catch (ExpectedError &e) { log(TF_ERR) << e.what() << flush; return 1; } catch (Bug &e) { log(TF_ERR) << e.what() << flush << "Backtrace:" << flush << e.backtrace() << flush << MSG_BUG << flush; return 2; } #endif // DISABLE_EXCEPTION_CATCHING return 0; } thinkfan-1.3.1/src/thinkfan.h000066400000000000000000000066651417751172400161060ustar00rootroot00000000000000/******************************************************************** * thinkfan.h: Global (i.e. process-wide) stuff. * (C) 2015, Victor Mataré * * this file is part of thinkfan. See thinkfan.c for further information. * * thinkfan is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * thinkfan 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. * * You should have received a copy of the GNU General Public License * along with thinkfan. If not, see . * * ******************************************************************/ #ifndef THINKFAN_H_ #define THINKFAN_H_ #include #include #include #include #include #include #define DEFAULT_CONFIG "/etc/thinkfan.conf" #define DEFAULT_YAML_CONFIG "/etc/thinkfan.yaml" #ifndef DEFAULT_FAN #define DEFAULT_FAN "/proc/acpi/ibm/fan" #endif #ifndef DEFAULT_SENSOR #define DEFAULT_SENSOR "/proc/acpi/ibm/thermal" #endif // Stolen from the gurus #define likely(x) __builtin_expect((x),1) #define unlikely(x) __builtin_expect((x),0) #if defined(__GNUC__) && __GNUC__ < 5 #define THINKFAN_IO_ERROR_CODE(e) errno #else #define THINKFAN_IO_ERROR_CODE(e) e.code().value() #endif namespace thinkfan { typedef std::string string; typedef std::ifstream ifstream; typedef std::ofstream ofstream; typedef std::fstream fstream; typedef std::chrono::duration seconds; typedef std::chrono::duration secondsf; template using vector = std::vector; template using shared_ptr = std::shared_ptr; template using unique_ptr = std::unique_ptr; template using pair = std::pair; template using numeric_limits = std::numeric_limits; class TemperatureState { public: TemperatureState(unsigned int num_temps); void restart(); void add_temp(int t); const vector &biased_temps() const; const vector &temps() const; const vector &biases() const; bool complete() const; void init(); private: vector temps_; vector biases_; vector biased_temps_; vector::iterator temp_; vector::iterator bias_; vector::iterator biased_temp_; public: vector::const_iterator tmax; }; #if defined(PID_FILE) class PidFileHolder { public: PidFileHolder(::pid_t pid); ~PidFileHolder(); static bool file_exists(); static void cleanup(); private: void remove_file(); std::fstream pid_file_; static PidFileHolder *instance_; }; #else class PidFileHolder { public: static void cleanup(); }; #endif // defined(PID_FILE) // Command line options extern bool chk_sanity; extern bool resume_is_safe; extern bool quiet; extern bool daemonize; #ifdef USE_ATASMART extern bool dnd_disk; #endif /* USE_ATASMART */ extern seconds sleeptime, tmp_sleeptime; extern float bias_level; extern std::atomic interrupted; extern vector config_files; extern float depulse; extern std::atomic tolerate_errors; extern std::condition_variable sleep_cond; extern std::mutex sleep_mutex; } #endif /* THINKFAN_H_ */ thinkfan-1.3.1/src/yamlconfig.cpp000066400000000000000000000524501417751172400167600ustar00rootroot00000000000000#include "yamlconfig.h" #include #include #include #include #include #include #include #include #include #include #include "message.h" namespace YAML { using namespace thinkfan; static const string kw_sensors("sensors"); static const string kw_fans("fans"); static const string kw_levels("levels"); static const string kw_tpacpi("tpacpi"); static const string kw_hwmon("hwmon"); #ifdef USE_NVML static const string kw_nvidia("nvml"); #endif #ifdef USE_ATASMART static const string kw_atasmart("atasmart"); #endif static const string kw_speed("speed"); static const string kw_upper("upper_limit"); static const string kw_lower("lower_limit"); static const string kw_name("name"); static const string kw_indices("indices"); static const string kw_correction("correction"); static const string kw_optional("optional"); #ifdef HAVE_OLD_YAMLCPP static inline Mark get_mark_compat(const Node &) { return Mark::null_mark(); } static inline BadConversion get_bad_conversion_compat(const Node &) { return BadConversion(); } #else static inline Mark get_mark_compat(const Node &node) { return node.Mark(); } static inline BadConversion get_bad_conversion_compat(const Node &node) { return BadConversion(node.Mark()); } #endif static int get_index(const string &fname, const string &pfx, const string &sfx) { int rv = -1; string::size_type i = fname.rfind(sfx); if (fname.substr(0, pfx.length()) == pfx && i != string::npos) { try { size_t idx_len; rv = stoi(fname.substr(pfx.length()), &idx_len, 10); if (fname.substr(pfx.length() + idx_len) != sfx) return -1; } catch (...) {} } return rv; } template static int get_index(const string &fname); template<> int get_index(const string &fname) { return get_index(fname, "temp", "_input"); } template<> int get_index(const string &fname) { return get_index(fname, "pwm", ""); } static vector filter_indices; static int file_filter(const struct dirent *entry, const string &pfx, const string &sfx) { if (entry->d_type == DT_REG) { int idx = get_index(entry->d_name, pfx, sfx); if (idx >= 0 && std::find(filter_indices.begin(), filter_indices.end(), idx) != filter_indices.end()) return 1; } return 0; } static int filter_temp_inputs(const struct dirent *entry) { return file_filter(entry, "temp", "_input"); } static int filter_pwms(const struct dirent *entry) { return file_filter(entry, "pwm", ""); } static int filter_hwmon_dirs(const struct dirent *entry) { if ((entry->d_type == DT_DIR || entry->d_type == DT_LNK) && ( !strncmp("hwmon", entry->d_name, 5) || !strcmp("device", entry->d_name))) return 1; return 0; } static int filter_subdirs(const struct dirent *entry) { return (entry->d_type & DT_DIR || entry->d_type == DT_LNK) && string(entry->d_name) != "." && string(entry->d_name) != ".." && string(entry->d_name) != "subsystem"; } template static int scandir(const string &path, struct dirent ***entries); template<> int scandir< HwmonSensorDriver > (const string &path, struct dirent ***entries) { return ::scandir(path.c_str(), entries, filter_temp_inputs, alphasort); } template<> int scandir< HwmonFanDriver > (const string &path, struct dirent ***entries) { return ::scandir(path.c_str(), entries, filter_pwms, alphasort); } static vector find_hwmons_by_name(string path, string name, unsigned char depth = 1) { const unsigned char max_depth = 5; vector result; ifstream f(path + "/name"); if (f.is_open() && f.good()) { string tmp; if ((f >> tmp) && tmp == name) { result.push_back(path); return result; } } if (depth >= max_depth) { return result; // don't recurse to subdirs } struct dirent **entries; int nentries = ::scandir(path.c_str(), &entries, filter_subdirs, nullptr); if (nentries == -1) { return result; } for (int i = 0; i < nentries; i++) { auto subdir = path + "/" + entries[i]->d_name; free(entries[i]); struct stat statbuf; int err = stat(path.c_str(), &statbuf); if (err || (statbuf.st_mode & S_IFMT) != S_IFDIR) continue; auto found = find_hwmons_by_name(subdir, name, depth + 1); result.insert(result.end(), found.begin(), found.end()); } free(entries); return result; } template string hwmon_filename(int index); template<> string hwmon_filename(int index) { return "temp" + std::to_string(index) + "_input"; } template<> string hwmon_filename(int index) { return "pwm" + std::to_string(index); } template static vector> find_hwmons_by_indices(string path, const vector &indices, ExtraArgTs... extra_args, unsigned char depth = 0) { vector> rv; const unsigned char max_depth = 3; filter_indices = indices; while (filter_indices.size() > 0 && depth <= max_depth) { struct dirent **entries; int nentries = scandir(path, &entries); if (nentries < 0) throw IOerror("Error scanning " + path + ": ", errno); int temp_idx = -1; if (nentries > 0) { for (int i = 0; i < nentries; i++) { temp_idx = get_index(entries[i]->d_name); if (temp_idx < 0) break; // no index found in file name auto it = std::find(filter_indices.begin(), filter_indices.end(), temp_idx); rv.push_back(make_wtf(path + "/" + entries[i]->d_name, extra_args...)); filter_indices.erase(it); // stop crawling at this level depth = std::numeric_limits::max(); } if (!filter_indices.empty()) { string list; for (int i : filter_indices) list += hwmon_filename(i) + ", "; list = list.substr(0, list.length() - 2); throw ConfigError("Could not find the following files at " + path + ": " + list); } } if (nentries == 0 || temp_idx < 0) { nentries = ::scandir(path.c_str(), &entries, filter_hwmon_dirs, alphasort); if (nentries < 0) throw IOerror("Error scanning " + path + ": ", errno); if (nentries > 0 && depth <= max_depth) { for (int i = 0; i < nentries && rv.empty(); i++) rv = find_hwmons_by_indices(path + "/" + entries[i]->d_name, indices, extra_args..., depth + 1); } else throw ConfigError("Could not find an `hwmon*' directory or `temp*_input' file in " + path + "."); } for (int i = 0; i < nentries; i++) free(entries[i]); free(entries); } return rv; } template inline bool decode_wrapexcept(const Node &node, T &output) { try { return convert::decode_inner(node, output); } catch (ConfigError &e) { throw YamlError(get_mark_compat(node), e.reason()); } } template<> struct convert>> { static bool decode(const Node &node, vector> &sensors) { return decode_wrapexcept(node, sensors); } static bool decode_inner(const Node &node, vector> &sensors) { if (!node[kw_hwmon]) return false; auto initial_size = sensors.size(); string path = node[kw_hwmon].as(); vector correction; if (node[kw_correction]) correction = node[kw_correction].as>(); if (node[kw_name]) { auto paths = find_hwmons_by_name(path, node[kw_name].as()); if (paths.size() != 1) { string msg; if (paths.size() == 0) { msg = MSG_HWMON_NOT_FOUND; } else { msg = MSG_MULTIPLE_HWMONS_FOUND; for (string hwmon_path : paths) { msg += " " + hwmon_path; } } throw YamlError(get_mark_compat(node[kw_name]), msg); } path = paths[0]; } bool optional = node[kw_optional] ? node[kw_optional].as() : false; if (node[kw_indices]) { vector indices = node[kw_indices].as>(); vector> hwmons = find_hwmons_by_indices(path, indices, optional); if (indices.size() != hwmons.size()) throw YamlError(get_mark_compat(node[kw_indices]), "Unable to find requested temperature inputs in " + path + "."); if (!correction.empty()) { if (correction.size() != hwmons.size()) throw YamlError( get_mark_compat(node[kw_indices]), MSG_CONF_CORRECTION_LEN(path, correction.size(), hwmons.size())); auto it = correction.begin(); std::for_each(hwmons.begin(), hwmons.end(), [&] (wtf_ptr &sensor) { sensor->set_correction(vector(1, *it++)); }); } for (wtf_ptr &h : hwmons) { sensors.push_back(std::move(h)); } } else { wtf_ptr h = make_wtf(path, optional, correction); sensors.push_back(h); } return sensors.size() > initial_size; } }; template<> struct convert> { static bool decode(const Node &node, wtf_ptr &sensor) { if (!node[kw_tpacpi]) return false; vector correction; if (node[kw_correction]) correction = node[kw_correction].as>(); bool optional = node[kw_optional] ? node[kw_optional].as() : false; if (node[kw_indices]) { sensor = make_wtf( node[kw_tpacpi].as(), optional, node[kw_indices].as>(), correction); } else sensor = make_wtf(node[kw_tpacpi].as(), optional, correction); return true; } }; #ifdef USE_NVML template<> struct convert> { static bool decode(const Node &node, wtf_ptr &sensor) { if (!node[kw_nvidia]) return false; vector correction; if (node[kw_correction]) correction = node[kw_correction].as>(); bool optional = node[kw_optional] ? node[kw_optional].as() : false; sensor = make_wtf(node[kw_nvidia].as(), optional, correction); return true; } }; #endif //USE_NVML #ifdef USE_ATASMART template<> struct convert> { static bool decode(const Node &node, wtf_ptr &sensor) { if (!node["atasmart"]) return false; vector correction; if (node[kw_correction]) correction = node[kw_correction].as>(); bool optional = node[kw_optional] ? node[kw_optional].as() : false; sensor = make_wtf(node["atasmart"].as(), optional, correction); return true; } }; #endif //USE_ATASMART template<> struct convert>> { static bool decode(const Node &node, vector> &sensors) { auto initial_size = sensors.size(); if (!node.IsSequence()) throw YamlError(get_mark_compat(node), "Sensor entries must be a sequence. Forgot the dashes?"); for (Node::const_iterator it = node.begin(); it != node.end(); ++it) { if ((*it)[kw_hwmon]) for (wtf_ptr h : it->as>>()) sensors.push_back(std::move(h)); else if ((*it)[kw_tpacpi]) { wtf_ptr tmp = it->as>(); sensors.push_back(std::move(tmp)); } #ifdef USE_NVML else if ((*it)[kw_nvidia]) { wtf_ptr tmp = it->as>(); sensors.push_back(std::move(tmp)); } #endif //USE_NVML #ifdef USE_ATASMART else if ((*it)[kw_atasmart]) { wtf_ptr tmp = it->as>(); sensors.push_back(std::move(tmp)); } #endif //USE_ATASMART else throw YamlError(get_mark_compat(*it), "Invalid sensor entry"); } return sensors.size() > initial_size; } }; template<> struct convert> { static bool decode(const Node &node, wtf_ptr &fan) { if (!node[kw_tpacpi]) return false; fan = make_wtf(node[kw_tpacpi].as()); return true; } }; template<> struct convert>> { static bool decode(const Node &node, vector> &fans) { return decode_wrapexcept(node, fans); } static bool decode_inner(const Node &node, vector> &fans) { if (!node[kw_hwmon]) return false; auto initial_size = fans.size(); string path = node[kw_hwmon].as(); if (node[kw_name]) { auto paths = find_hwmons_by_name(path, node[kw_name].as()); if (paths.size() != 1) { string msg; if (paths.size() == 0) { msg = MSG_HWMON_NOT_FOUND; } else { msg = MSG_MULTIPLE_HWMONS_FOUND; for (string hwmon_path : paths) { msg += " " + hwmon_path; } } throw YamlError(get_mark_compat(node[kw_name]), msg); } path = paths[0]; } if (node[kw_indices]) { vector indices = node[kw_indices].as>(); fans = find_hwmons_by_indices(path, indices); if (indices.size() != fans.size()) throw YamlError(get_mark_compat(node[kw_indices]), "Unable to find requested PWM controls in " + path + "."); } else fans.push_back(make_wtf(node[kw_hwmon].as())); return fans.size() > initial_size; } }; void assign_fan_levels(vector> &fan_configs, const Node &entry) { try { LevelEntry lvl_entry = entry.as(); if (lvl_entry.fan_levels.size() != fan_configs.size()) throw YamlError(get_mark_compat(entry), "Number of " + kw_speed + " entries doesn't match number of " + kw_fans ); size_t fan_idx = 0; for (unique_ptr &fan_cfg : fan_configs) { try { fan_cfg->add_level( std::make_unique( lvl_entry.fan_levels[fan_idx].first, lvl_entry.lower_limit, lvl_entry.upper_limit ) ); } catch (ConfigError &e) { throw YamlError(get_mark_compat(entry), e.what()); } ++fan_idx; } } catch (YAML::BadConversion &) { for (unique_ptr &fan_cfg : fan_configs) { // Have to copy the wtf_ptr first because frickin Ubuntu still haven't updated their libyaml-cpp wtf_ptr l = entry.as>(); fan_cfg->add_level(unique_ptr(l.release())); } } } template<> struct convert>> { static bool decode(const Node &fans_node, vector> &fan_configs) { auto initial_size = fan_configs.size(); vector> fan_drivers; if (!fans_node.IsSequence()) throw YamlError(get_mark_compat(fans_node), "Fan entries must be a sequence. Forgot the dashes?"); for (Node::const_iterator fans_it = fans_node.begin(); fans_it != fans_node.end(); ++fans_it) { try { for (auto f : fans_it->as>>()) fan_drivers.push_back(unique_ptr(f.release())); } catch (BadConversion &) { // Have to copy the wtf_ptr first because frickin Ubuntu still haven't updated their libyaml-cpp wtf_ptr f { fans_it->as>() }; fan_drivers.push_back(unique_ptr(f.release())); } const Node levels_node = (*fans_it)[kw_levels]; if (levels_node) { if (!levels_node.IsSequence()) throw YamlError( get_mark_compat(levels_node), "Level entries must be a sequence. Forgot the dashes?" ); vector> stepwise_mappings; for (unique_ptr &fan_drv : fan_drivers) { stepwise_mappings.push_back( std::make_unique(std::move(fan_drv)) ); } fan_drivers.clear(); for (const Node &lvl : levels_node) assign_fan_levels(stepwise_mappings, lvl); for (unique_ptr &mapping : stepwise_mappings) // Jump through ALL the Ubuntu hoops (.............................................) fan_configs.push_back(wtf_ptr(new unique_ptr(std::move(mapping)))); } } return fan_configs.size() > initial_size; } }; vector get_limit(const Node &n) { vector rv; if (!n.IsSequence()) throw YamlError(get_mark_compat(n), "Temperature limit must be a sequence"); for (const Node &m : n) { try { int i = m.as(); if (i == numeric_limits::min()) throw YamlError(get_mark_compat(m), std::to_string(i) + " is not a valid temperature limit"); rv.push_back(i); } catch (BadConversion &) { string s = m.as(); if (s != "_") throw YamlError(get_mark_compat(m), s + " is not a valid temperature limit"); rv.push_back(std::numeric_limits::max()); } } return rv; } pair get_fan_level(const Node &n) { int level_n; string level_s; try { level_n = n.as(); if (level_n == 127) level_s = "level disengaged"; else level_s = "level " + std::to_string(level_n); } catch (BadConversion &) { level_s = n.as(); level_n = Level::string_to_int(level_s); } return {level_s, level_n}; } template<> struct convert { static bool decode(const Node &node, LevelEntry &rv) { const Node &n_lower = node[kw_lower], &n_upper = node[kw_upper]; if (!(node[kw_speed] && (n_lower || n_upper))) return false; if (node[kw_speed].IsSequence()) { for (const Node &n_lvl : node[kw_speed]) rv.fan_levels.push_back(get_fan_level(n_lvl)); } else rv.fan_levels.push_back(get_fan_level(node[kw_speed])); if (n_lower) rv.lower_limit = get_limit(n_lower); if (n_upper) rv.upper_limit = get_limit(n_upper); if (rv.lower_limit.empty()) rv.lower_limit = vector(rv.upper_limit.size(), numeric_limits::min()); else if (rv.upper_limit.empty()) rv.upper_limit = vector(rv.lower_limit.size(), numeric_limits::max()); return true; } }; template<> struct convert> { static bool decode(const Node &node, wtf_ptr &level) { const Node &n_lower = node[kw_lower], &n_upper = node[kw_upper]; if (!(node[kw_speed] && (n_lower || n_upper))) { if (!node.IsSequence()) return false; try { level = make_wtf(node[0].as(), node[1].as(), node[2].as()); } catch (BadConversion &) { level = make_wtf(node[0].as(), node[1].as(), node[2].as()); } } else { int lower, upper; if (n_lower) { lower = n_lower.as(); if (lower == numeric_limits::min()) throw get_bad_conversion_compat(n_lower); } else lower = numeric_limits::min(); if (n_upper) { upper = n_upper.as(); if (upper == numeric_limits::max()) throw get_bad_conversion_compat(n_upper); } else upper = numeric_limits::max(); try { level = make_wtf(node[kw_speed].as(), lower, upper); } catch (BadConversion &) { level = make_wtf(node[kw_speed].as(), lower, upper); } } return true; } }; bool convert>::decode(const Node &node, wtf_ptr &config) { if (!node.size()) throw ParserException(get_mark_compat(node), "Invalid YAML syntax"); config = make_wtf(); for (YAML::const_iterator it = node.begin(); it != node.end(); ++it) { const string key = it->first.as(); if (key != kw_sensors && key != kw_fans && key != kw_levels) throw YamlError(get_mark_compat(it->first), "Unknown keyword"); } if (node[kw_sensors]) { for (auto s : node[kw_sensors].as>>()) config->add_sensor(unique_ptr(s.release())); } else throw YamlError(get_mark_compat(node), "Missing \"sensors:\" entry"); if (node[kw_fans]) { try { // Each fan with its own levels section (supports multiple fans) for (auto fan_cfg : node[kw_fans].as>>()) { // Have to copy the wtf_ptr first because frickin Ubuntu still haven't updated their libyaml-cpp wtf_ptr fu { fan_cfg }; // It's const on feckin Ubuntu config->add_fan_config(unique_ptr(fu.release())); } } catch (BadConversion &) { // Single fan entry with separate levels section below. vector> fans; if (node[kw_fans].size() > 1) throw YamlError(get_mark_compat(node[kw_fans]), "When multiple fans are configured, each must have its own 'levels:' section"); try { wtf_ptr fu { node[kw_fans][0].as>() }; fans.push_back(unique_ptr(fu.release())); } catch (BadConversion &) { for (auto &fan_drv : node[kw_fans][0].as>>()) { wtf_ptr fu { fan_drv }; fans.push_back(unique_ptr(fu.release())); } } vector> fan_configs; for (unique_ptr &fan : fans) fan_configs.push_back(std::make_unique(std::move(fan))); fans.clear(); if (node[kw_levels]) { // Separate "levels:" section if (config->fan_configs().size()) throw YamlError(get_mark_compat(node), "Cannot have a separate 'levels:' section when some fan already has specific levels assigned"); if (!node[kw_levels].IsSequence()) throw YamlError(get_mark_compat(node), "Level entries must be a sequence. Forgot the dashes?"); for (const Node &n_lvl : node[kw_levels]) assign_fan_levels(fan_configs, n_lvl); for (unique_ptr &fan_cfg : fan_configs) config->add_fan_config(std::move(fan_cfg)); } else throw YamlError(get_mark_compat(node), "Missing \"levels:\" entry"); } } else throw YamlError(get_mark_compat(node), "Missing \"fans:\" entry"); return true; } } thinkfan-1.3.1/src/yamlconfig.h000066400000000000000000000033341417751172400164220ustar00rootroot00000000000000#ifndef THINKFAN_YAMLCONFIG_H_ #define THINKFAN_YAMLCONFIG_H_ #include "config.h" #include "thinkfan.h" #include #include #include namespace YAML { using namespace thinkfan; /** * This is the glorious wtf_ptr which unifies shared_ptr semantics with * the unique_ptr's ability to release(), i.e. relinquish ownership. * This weird hack is required since yaml-cpp cannot deal with non-copyable types like * unique_ptr. I'm sorry. */ template class wtf_ptr : public shared_ptr>, public std::enable_shared_from_this> { public: using shared_ptr>::shared_ptr; template wtf_ptr(wtf_ptr &&ptr) : shared_ptr>(new unique_ptr(ptr.release())) {} wtf_ptr() : shared_ptr>() {} wtf_ptr(T *ptr) : shared_ptr>(new unique_ptr(ptr)) {} auto release() { return *this ? this->get()->release() : nullptr; } auto operator -> () const { return this->get()->operator -> (); } auto operator * () const { return this->get()->operator * (); } template wtf_ptr &operator = (const wtf_ptr& ptr) noexcept { return this->shared_ptr>::operator = (ptr); } }; template wtf_ptr make_wtf(TArgs... args) { return wtf_ptr(new unique_ptr(new T(args...))); } template<> struct convert> { static bool decode(const Node &node, wtf_ptr &config); }; template inline bool decode_inner(const Node &node, T &output); struct LevelEntry { vector> fan_levels; vector lower_limit; vector upper_limit; }; } #endif // THINKFAN_YAMLCONFIG_H_